001/*
002// This software is subject to the terms of the Eclipse Public License v1.0
003// Agreement, available at the following URL:
004// http://www.eclipse.org/legal/epl-v10.html.
005// You must accept the terms of that agreement to use this software.
006//
007// Copyright (C) 2007-2012 Pentaho
008// All Rights Reserved.
009*/
010package mondrian.olap4j;
011
012import mondrian.olap.Axis;
013import mondrian.olap.*;
014import mondrian.rolap.RolapAxis;
015import mondrian.rolap.RolapCell;
016import mondrian.server.Execution;
017import mondrian.spi.ProfileHandler;
018
019import org.olap4j.Cell;
020import org.olap4j.*;
021import org.olap4j.Position;
022
023import java.io.*;
024import java.math.BigDecimal;
025import java.net.URL;
026import java.sql.*;
027import java.sql.Date;
028import java.util.*;
029
030/**
031 * Implementation of {@link CellSet}
032 * for the Mondrian OLAP engine.
033 *
034 * <p>This class has sub-classes which implement JDBC 3.0 and JDBC 4.0 APIs;
035 * it is instantiated using {@link Factory#newCellSet}.</p>
036 *
037 * @author jhyde
038 * @since May 24, 2007
039 */
040abstract class MondrianOlap4jCellSet
041    extends Execution
042    implements CellSet
043{
044    final MondrianOlap4jStatement olap4jStatement;
045    final Query query;
046    private Result result;
047    protected boolean closed;
048    private final MondrianOlap4jCellSetMetaData metaData;
049    private final List<CellSetAxis> axisList =
050        new ArrayList<CellSetAxis>();
051    private CellSetAxis filterAxis;
052
053    /**
054     * Creates a MondrianOlap4jCellSet.
055     *
056     * @param olap4jStatement Statement
057     */
058    public MondrianOlap4jCellSet(
059        MondrianOlap4jStatement olap4jStatement)
060    {
061        super(olap4jStatement, olap4jStatement.getQueryTimeoutMillis());
062        this.olap4jStatement = olap4jStatement;
063        this.query = olap4jStatement.getQuery();
064        assert query != null;
065        this.closed = false;
066        if (olap4jStatement instanceof MondrianOlap4jPreparedStatement) {
067            this.metaData =
068                ((MondrianOlap4jPreparedStatement) olap4jStatement)
069                    .cellSetMetaData;
070        } else {
071            this.metaData =
072                new MondrianOlap4jCellSetMetaData(
073                    olap4jStatement, query);
074        }
075    }
076
077    /**
078     * Executes a query. Not part of the olap4j API; internal to the mondrian
079     * driver.
080     *
081     * <p>This method may take some time. While it is executing, a client may
082     * execute {@link MondrianOlap4jStatement#cancel()}.
083     *
084     * @throws org.olap4j.OlapException on error
085     */
086    void execute() throws OlapException {
087        result =
088            olap4jStatement.olap4jConnection.getMondrianConnection().execute(
089                this);
090
091        // initialize axes
092        mondrian.olap.Axis[] axes = result.getAxes();
093        QueryAxis[] queryAxes = result.getQuery().getAxes();
094        assert axes.length == queryAxes.length;
095        for (int i = 0; i < axes.length; i++) {
096            Axis axis = axes[i];
097            QueryAxis queryAxis = queryAxes[i];
098            axisList.add(
099                new MondrianOlap4jCellSetAxis(
100                    this, queryAxis, (RolapAxis) axis));
101        }
102
103        // initialize filter axis
104        QueryAxis queryAxis = result.getQuery().getSlicerAxis();
105        final Axis axis = result.getSlicerAxis();
106        if (queryAxis == null) {
107            // Dummy slicer axis.
108            queryAxis =
109                new QueryAxis(
110                    false, null, AxisOrdinal.StandardAxisOrdinal.SLICER,
111                    QueryAxis.SubtotalVisibility.Undefined);
112        }
113        filterAxis =
114            new MondrianOlap4jCellSetAxis(this, queryAxis, (RolapAxis) axis);
115    }
116
117    public CellSetMetaData getMetaData() {
118        return metaData;
119    }
120
121    public List<CellSetAxis> getAxes() {
122        return axisList;
123    }
124
125    public CellSetAxis getFilterAxis() {
126        return filterAxis;
127    }
128
129    public Cell getCell(List<Integer> coordinates) {
130        int[] coords = new int[coordinates.size()];
131        for (int i = 0; i < coords.length; i++) {
132            coords[i] = coordinates.get(i);
133        }
134        return getCellInternal(coords);
135    }
136
137    public Cell getCell(int ordinal) {
138        final int[] pos = ordinalToCoordinateArray(ordinal);
139        return getCellInternal(pos);
140    }
141
142    private int[] ordinalToCoordinateArray(int ordinal) {
143        Axis[] axes = result.getAxes();
144        final int[] pos = new int[axes.length];
145        int modulo = 1;
146        for (int i = 0; i < axes.length; i++) {
147            int prevModulo = modulo;
148            modulo *= axes[i].getPositions().size();
149            pos[i] = (ordinal % modulo) / prevModulo;
150        }
151        if (ordinal < 0 || ordinal >= modulo) {
152            throw new IndexOutOfBoundsException(
153                "Cell ordinal " + ordinal
154                + ") lies outside CellSet bounds ("
155                + getBoundsAsString() + ")");
156        }
157        return pos;
158    }
159
160    public Cell getCell(Position... positions) {
161        int[] coords = new int[positions.length];
162        for (int i = 0; i < coords.length; i++) {
163            coords[i] = positions[i].getOrdinal();
164        }
165        return getCellInternal(coords);
166    }
167
168    private Cell getCellInternal(int[] pos) {
169        RolapCell cell;
170        try {
171            cell = (RolapCell) result.getCell(pos);
172        } catch (MondrianException e) {
173            if (e.getMessage().indexOf("coordinates out of range") >= 0) {
174                int[] dimensions = new int[getAxes().size()];
175                for (int i = 0; i < axisList.size(); i++) {
176                    dimensions[i] = axisList.get(i).getPositions().size();
177                }
178                throw new IndexOutOfBoundsException(
179                    "Cell coordinates (" + getCoordsAsString(pos)
180                        + ") fall outside CellSet bounds ("
181                        + getCoordsAsString(dimensions) + ")");
182            } else if (e.getMessage().indexOf(
183                    "coordinates should have dimension") >= 0)
184            {
185                throw new IllegalArgumentException(
186                    "Cell coordinates should have dimension "
187                        + axisList.size());
188            } else {
189                throw e;
190            }
191        }
192        return new MondrianOlap4jCell(pos, this, cell);
193    }
194
195    private String getBoundsAsString() {
196        StringBuilder buf = new StringBuilder();
197        Axis[] axes = result.getAxes();
198        for (int i = 0; i < axes.length; i++) {
199            if (i > 0) {
200                buf.append(", ");
201            }
202            buf.append(axes[i].getPositions().size());
203        }
204        return buf.toString();
205    }
206
207    private static String getCoordsAsString(int[] pos) {
208        StringBuilder buf = new StringBuilder();
209        for (int i = 0; i < pos.length; i++) {
210            int po = pos[i];
211            if (i > 0) {
212                buf.append(", ");
213            }
214            buf.append(po);
215        }
216        return buf.toString();
217    }
218
219    public List<Integer> ordinalToCoordinates(int ordinal) {
220        final int[] ints = ordinalToCoordinateArray(ordinal);
221        final List<Integer> list = new ArrayList<Integer>(ints.length);
222        for (int i : ints) {
223            list.add(i);
224        }
225        return list;
226    }
227
228    public int coordinatesToOrdinal(List<Integer> coordinates) {
229        List<CellSetAxis> axes = getAxes();
230        if (coordinates.size() != axes.size()) {
231            throw new IllegalArgumentException(
232                "Coordinates have different dimension " + coordinates.size()
233                    + " than axes " + axes.size());
234        }
235        int modulo = 1;
236        int ordinal = 0;
237        int k = 0;
238        for (CellSetAxis axis : axes) {
239            final Integer coordinate = coordinates.get(k++);
240            if (coordinate < 0 || coordinate >= axis.getPositionCount()) {
241                throw new IndexOutOfBoundsException(
242                    "Coordinate " + coordinate
243                    + " of axis " + k
244                    + " is out of range ("
245                    + getBoundsAsString() + ")");
246            }
247            ordinal += coordinate * modulo;
248            modulo *= axis.getPositionCount();
249        }
250        return ordinal;
251    }
252
253    public boolean next() throws SQLException {
254        throw new UnsupportedOperationException();
255    }
256
257    public void close() {
258        if (closed) {
259            return;
260        }
261        this.closed = true;
262        final ProfileHandler profileHandler =
263            olap4jStatement.getProfileHandler();
264        if (profileHandler != null) {
265            final StringWriter stringWriter = new StringWriter();
266            final PrintWriter printWriter = new PrintWriter(stringWriter);
267            olap4jStatement.getQuery().explain(printWriter);
268            printWriter.close();
269            profileHandler.explain(stringWriter.toString(), getQueryTiming());
270        }
271        if (this.result != null) {
272            this.result.close();
273        }
274        olap4jStatement.onResultSetClose(this);
275    }
276
277    public boolean wasNull() throws SQLException {
278        throw new UnsupportedOperationException();
279    }
280
281    public String getString(int columnIndex) throws SQLException {
282        throw new UnsupportedOperationException();
283    }
284
285    public boolean getBoolean(int columnIndex) throws SQLException {
286        throw new UnsupportedOperationException();
287    }
288
289    public byte getByte(int columnIndex) throws SQLException {
290        throw new UnsupportedOperationException();
291    }
292
293    public short getShort(int columnIndex) throws SQLException {
294        throw new UnsupportedOperationException();
295    }
296
297    public int getInt(int columnIndex) throws SQLException {
298        throw new UnsupportedOperationException();
299    }
300
301    public long getLong(int columnIndex) throws SQLException {
302        throw new UnsupportedOperationException();
303    }
304
305    public float getFloat(int columnIndex) throws SQLException {
306        throw new UnsupportedOperationException();
307    }
308
309    public double getDouble(int columnIndex) throws SQLException {
310        throw new UnsupportedOperationException();
311    }
312
313    public BigDecimal getBigDecimal(
314        int columnIndex, int scale) throws SQLException
315    {
316        throw new UnsupportedOperationException();
317    }
318
319    public byte[] getBytes(int columnIndex) throws SQLException {
320        throw new UnsupportedOperationException();
321    }
322
323    public Date getDate(int columnIndex) throws SQLException {
324        throw new UnsupportedOperationException();
325    }
326
327    public Time getTime(int columnIndex) throws SQLException {
328        throw new UnsupportedOperationException();
329    }
330
331    public Timestamp getTimestamp(int columnIndex) throws SQLException {
332        throw new UnsupportedOperationException();
333    }
334
335    public InputStream getAsciiStream(int columnIndex) throws SQLException {
336        throw new UnsupportedOperationException();
337    }
338
339    public InputStream getUnicodeStream(int columnIndex) throws SQLException {
340        throw new UnsupportedOperationException();
341    }
342
343    public InputStream getBinaryStream(int columnIndex) throws SQLException {
344        throw new UnsupportedOperationException();
345    }
346
347    public String getString(String columnLabel) throws SQLException {
348        throw new UnsupportedOperationException();
349    }
350
351    public boolean getBoolean(String columnLabel) throws SQLException {
352        throw new UnsupportedOperationException();
353    }
354
355    public byte getByte(String columnLabel) throws SQLException {
356        throw new UnsupportedOperationException();
357    }
358
359    public short getShort(String columnLabel) throws SQLException {
360        throw new UnsupportedOperationException();
361    }
362
363    public int getInt(String columnLabel) throws SQLException {
364        throw new UnsupportedOperationException();
365    }
366
367    public long getLong(String columnLabel) throws SQLException {
368        throw new UnsupportedOperationException();
369    }
370
371    public float getFloat(String columnLabel) throws SQLException {
372        throw new UnsupportedOperationException();
373    }
374
375    public double getDouble(String columnLabel) throws SQLException {
376        throw new UnsupportedOperationException();
377    }
378
379    public BigDecimal getBigDecimal(
380        String columnLabel, int scale) throws SQLException
381    {
382        throw new UnsupportedOperationException();
383    }
384
385    public byte[] getBytes(String columnLabel) throws SQLException {
386        throw new UnsupportedOperationException();
387    }
388
389    public Date getDate(String columnLabel) throws SQLException {
390        throw new UnsupportedOperationException();
391    }
392
393    public Time getTime(String columnLabel) throws SQLException {
394        throw new UnsupportedOperationException();
395    }
396
397    public Timestamp getTimestamp(String columnLabel) throws SQLException {
398        throw new UnsupportedOperationException();
399    }
400
401    public InputStream getAsciiStream(String columnLabel) throws SQLException {
402        throw new UnsupportedOperationException();
403    }
404
405    public InputStream getUnicodeStream(
406        String columnLabel) throws SQLException
407    {
408        throw new UnsupportedOperationException();
409    }
410
411    public InputStream getBinaryStream(String columnLabel) throws SQLException {
412        throw new UnsupportedOperationException();
413    }
414
415    public SQLWarning getWarnings() throws SQLException {
416        throw new UnsupportedOperationException();
417    }
418
419    public void clearWarnings() throws SQLException {
420        throw new UnsupportedOperationException();
421    }
422
423    public String getCursorName() throws SQLException {
424        throw new UnsupportedOperationException();
425    }
426
427    public Object getObject(int columnIndex) throws SQLException {
428        throw new UnsupportedOperationException();
429    }
430
431    public Object getObject(String columnLabel) throws SQLException {
432        throw new UnsupportedOperationException();
433    }
434
435    public int findColumn(String columnLabel) throws SQLException {
436        throw new UnsupportedOperationException();
437    }
438
439    public Reader getCharacterStream(int columnIndex) throws SQLException {
440        throw new UnsupportedOperationException();
441    }
442
443    public Reader getCharacterStream(String columnLabel) throws SQLException {
444        throw new UnsupportedOperationException();
445    }
446
447    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
448        throw new UnsupportedOperationException();
449    }
450
451    public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
452        throw new UnsupportedOperationException();
453    }
454
455    public boolean isBeforeFirst() throws SQLException {
456        throw new UnsupportedOperationException();
457    }
458
459    public boolean isAfterLast() throws SQLException {
460        throw new UnsupportedOperationException();
461    }
462
463    public boolean isFirst() throws SQLException {
464        throw new UnsupportedOperationException();
465    }
466
467    public boolean isLast() throws SQLException {
468        throw new UnsupportedOperationException();
469    }
470
471    public void beforeFirst() throws SQLException {
472        throw new UnsupportedOperationException();
473    }
474
475    public void afterLast() throws SQLException {
476        throw new UnsupportedOperationException();
477    }
478
479    public boolean first() throws SQLException {
480        throw new UnsupportedOperationException();
481    }
482
483    public boolean last() throws SQLException {
484        throw new UnsupportedOperationException();
485    }
486
487    public int getRow() throws SQLException {
488        throw new UnsupportedOperationException();
489    }
490
491    public boolean absolute(int row) throws SQLException {
492        throw new UnsupportedOperationException();
493    }
494
495    public boolean relative(int rows) throws SQLException {
496        throw new UnsupportedOperationException();
497    }
498
499    public boolean previous() throws SQLException {
500        throw new UnsupportedOperationException();
501    }
502
503    public void setFetchDirection(int direction) throws SQLException {
504        throw new UnsupportedOperationException();
505    }
506
507    public int getFetchDirection() throws SQLException {
508        throw new UnsupportedOperationException();
509    }
510
511    public void setFetchSize(int rows) throws SQLException {
512        throw new UnsupportedOperationException();
513    }
514
515    public int getFetchSize() throws SQLException {
516        throw new UnsupportedOperationException();
517    }
518
519    public int getType() throws SQLException {
520        throw new UnsupportedOperationException();
521    }
522
523    public int getConcurrency() throws SQLException {
524        throw new UnsupportedOperationException();
525    }
526
527    public boolean rowUpdated() throws SQLException {
528        throw new UnsupportedOperationException();
529    }
530
531    public boolean rowInserted() throws SQLException {
532        throw new UnsupportedOperationException();
533    }
534
535    public boolean rowDeleted() throws SQLException {
536        throw new UnsupportedOperationException();
537    }
538
539    public void updateNull(int columnIndex) throws SQLException {
540        throw new UnsupportedOperationException();
541    }
542
543    public void updateBoolean(int columnIndex, boolean x) throws SQLException {
544        throw new UnsupportedOperationException();
545    }
546
547    public void updateByte(int columnIndex, byte x) throws SQLException {
548        throw new UnsupportedOperationException();
549    }
550
551    public void updateShort(int columnIndex, short x) throws SQLException {
552        throw new UnsupportedOperationException();
553    }
554
555    public void updateInt(int columnIndex, int x) throws SQLException {
556        throw new UnsupportedOperationException();
557    }
558
559    public void updateLong(int columnIndex, long x) throws SQLException {
560        throw new UnsupportedOperationException();
561    }
562
563    public void updateFloat(int columnIndex, float x) throws SQLException {
564        throw new UnsupportedOperationException();
565    }
566
567    public void updateDouble(int columnIndex, double x) throws SQLException {
568        throw new UnsupportedOperationException();
569    }
570
571    public void updateBigDecimal(
572        int columnIndex, BigDecimal x) throws SQLException
573    {
574        throw new UnsupportedOperationException();
575    }
576
577    public void updateString(int columnIndex, String x) throws SQLException {
578        throw new UnsupportedOperationException();
579    }
580
581    public void updateBytes(int columnIndex, byte x[]) throws SQLException {
582        throw new UnsupportedOperationException();
583    }
584
585    public void updateDate(int columnIndex, Date x) throws SQLException {
586        throw new UnsupportedOperationException();
587    }
588
589    public void updateTime(int columnIndex, Time x) throws SQLException {
590        throw new UnsupportedOperationException();
591    }
592
593    public void updateTimestamp(
594        int columnIndex, Timestamp x) throws SQLException
595    {
596        throw new UnsupportedOperationException();
597    }
598
599    public void updateAsciiStream(
600        int columnIndex, InputStream x, int length) throws SQLException
601    {
602        throw new UnsupportedOperationException();
603    }
604
605    public void updateBinaryStream(
606        int columnIndex, InputStream x, int length) throws SQLException
607    {
608        throw new UnsupportedOperationException();
609    }
610
611    public void updateCharacterStream(
612        int columnIndex, Reader x, int length) throws SQLException
613    {
614        throw new UnsupportedOperationException();
615    }
616
617    public void updateObject(
618        int columnIndex, Object x, int scaleOrLength) throws SQLException
619    {
620        throw new UnsupportedOperationException();
621    }
622
623    public void updateObject(int columnIndex, Object x) throws SQLException {
624        throw new UnsupportedOperationException();
625    }
626
627    public void updateNull(String columnLabel) throws SQLException {
628        throw new UnsupportedOperationException();
629    }
630
631    public void updateBoolean(
632        String columnLabel, boolean x) throws SQLException
633    {
634        throw new UnsupportedOperationException();
635    }
636
637    public void updateByte(String columnLabel, byte x) throws SQLException {
638        throw new UnsupportedOperationException();
639    }
640
641    public void updateShort(String columnLabel, short x) throws SQLException {
642        throw new UnsupportedOperationException();
643    }
644
645    public void updateInt(String columnLabel, int x) throws SQLException {
646        throw new UnsupportedOperationException();
647    }
648
649    public void updateLong(String columnLabel, long x) throws SQLException {
650        throw new UnsupportedOperationException();
651    }
652
653    public void updateFloat(String columnLabel, float x) throws SQLException {
654        throw new UnsupportedOperationException();
655    }
656
657    public void updateDouble(String columnLabel, double x) throws SQLException {
658        throw new UnsupportedOperationException();
659    }
660
661    public void updateBigDecimal(
662        String columnLabel, BigDecimal x) throws SQLException
663    {
664        throw new UnsupportedOperationException();
665    }
666
667    public void updateString(String columnLabel, String x) throws SQLException {
668        throw new UnsupportedOperationException();
669    }
670
671    public void updateBytes(String columnLabel, byte x[]) throws SQLException {
672        throw new UnsupportedOperationException();
673    }
674
675    public void updateDate(String columnLabel, Date x) throws SQLException {
676        throw new UnsupportedOperationException();
677    }
678
679    public void updateTime(String columnLabel, Time x) throws SQLException {
680        throw new UnsupportedOperationException();
681    }
682
683    public void updateTimestamp(
684        String columnLabel, Timestamp x) throws SQLException
685    {
686        throw new UnsupportedOperationException();
687    }
688
689    public void updateAsciiStream(
690        String columnLabel, InputStream x, int length) throws SQLException
691    {
692        throw new UnsupportedOperationException();
693    }
694
695    public void updateBinaryStream(
696        String columnLabel, InputStream x, int length) throws SQLException
697    {
698        throw new UnsupportedOperationException();
699    }
700
701    public void updateCharacterStream(
702        String columnLabel, Reader reader, int length) throws SQLException
703    {
704        throw new UnsupportedOperationException();
705    }
706
707    public void updateObject(
708        String columnLabel, Object x, int scaleOrLength) throws SQLException
709    {
710        throw new UnsupportedOperationException();
711    }
712
713    public void updateObject(String columnLabel, Object x) throws SQLException {
714        throw new UnsupportedOperationException();
715    }
716
717    public void insertRow() throws SQLException {
718        throw new UnsupportedOperationException();
719    }
720
721    public void updateRow() throws SQLException {
722        throw new UnsupportedOperationException();
723    }
724
725    public void deleteRow() throws SQLException {
726        throw new UnsupportedOperationException();
727    }
728
729    public void refreshRow() throws SQLException {
730        throw new UnsupportedOperationException();
731    }
732
733    public void cancelRowUpdates() throws SQLException {
734        throw new UnsupportedOperationException();
735    }
736
737    public void moveToInsertRow() throws SQLException {
738        throw new UnsupportedOperationException();
739    }
740
741    public void moveToCurrentRow() throws SQLException {
742        throw new UnsupportedOperationException();
743    }
744
745    public OlapStatement getStatement() {
746        return olap4jStatement;
747    }
748
749    public Object getObject(
750        int columnIndex, Map<String, Class<?>> map) throws SQLException
751    {
752        throw new UnsupportedOperationException();
753    }
754
755    public Ref getRef(int columnIndex) throws SQLException {
756        throw new UnsupportedOperationException();
757    }
758
759    public Blob getBlob(int columnIndex) throws SQLException {
760        throw new UnsupportedOperationException();
761    }
762
763    public Clob getClob(int columnIndex) throws SQLException {
764        throw new UnsupportedOperationException();
765    }
766
767    public Array getArray(int columnIndex) throws SQLException {
768        throw new UnsupportedOperationException();
769    }
770
771    public Object getObject(
772        String columnLabel, Map<String, Class<?>> map) throws SQLException
773    {
774        throw new UnsupportedOperationException();
775    }
776
777    public Ref getRef(String columnLabel) throws SQLException {
778        throw new UnsupportedOperationException();
779    }
780
781    public Blob getBlob(String columnLabel) throws SQLException {
782        throw new UnsupportedOperationException();
783    }
784
785    public Clob getClob(String columnLabel) throws SQLException {
786        throw new UnsupportedOperationException();
787    }
788
789    public Array getArray(String columnLabel) throws SQLException {
790        throw new UnsupportedOperationException();
791    }
792
793    public Date getDate(int columnIndex, Calendar cal) throws SQLException {
794        throw new UnsupportedOperationException();
795    }
796
797    public Date getDate(String columnLabel, Calendar cal) throws SQLException {
798        throw new UnsupportedOperationException();
799    }
800
801    public Time getTime(int columnIndex, Calendar cal) throws SQLException {
802        throw new UnsupportedOperationException();
803    }
804
805    public Time getTime(String columnLabel, Calendar cal) throws SQLException {
806        throw new UnsupportedOperationException();
807    }
808
809    public Timestamp getTimestamp(
810        int columnIndex, Calendar cal) throws SQLException
811    {
812        throw new UnsupportedOperationException();
813    }
814
815    public Timestamp getTimestamp(
816        String columnLabel, Calendar cal) throws SQLException
817    {
818        throw new UnsupportedOperationException();
819    }
820
821    public URL getURL(int columnIndex) throws SQLException {
822        throw new UnsupportedOperationException();
823    }
824
825    public URL getURL(String columnLabel) throws SQLException {
826        throw new UnsupportedOperationException();
827    }
828
829    public void updateRef(int columnIndex, Ref x) throws SQLException {
830        throw new UnsupportedOperationException();
831    }
832
833    public void updateRef(String columnLabel, Ref x) throws SQLException {
834        throw new UnsupportedOperationException();
835    }
836
837    public void updateBlob(int columnIndex, Blob x) throws SQLException {
838        throw new UnsupportedOperationException();
839    }
840
841    public void updateBlob(String columnLabel, Blob x) throws SQLException {
842        throw new UnsupportedOperationException();
843    }
844
845    public void updateClob(int columnIndex, Clob x) throws SQLException {
846        throw new UnsupportedOperationException();
847    }
848
849    public void updateClob(String columnLabel, Clob x) throws SQLException {
850        throw new UnsupportedOperationException();
851    }
852
853    public void updateArray(int columnIndex, Array x) throws SQLException {
854        throw new UnsupportedOperationException();
855    }
856
857    public void updateArray(String columnLabel, Array x) throws SQLException {
858        throw new UnsupportedOperationException();
859    }
860
861    // implement Wrapper
862
863    public <T> T unwrap(Class<T> iface) throws SQLException {
864        throw new UnsupportedOperationException();
865    }
866
867    public boolean isWrapperFor(Class<?> iface) throws SQLException {
868        throw new UnsupportedOperationException();
869    }
870}
871
872// End MondrianOlap4jCellSet.java