src/jdbc/JdbcSqlResultSet.java

   1
   2 package csql.jdbc;
   3
   4 import java.math.BigDecimal;
   5 import java.net.URL;
   6
   7 import java.sql.Connection;
   8 import java.sql.Statement;
   9 import java.sql.SQLException;
  10 import java.sql.ResultSet;
  11 import java.sql.ResultSetMetaData;
  12 import java.sql.SQLWarning;
  13
  14 import java.io.InputStream;
  15 import java.io.InputStreamReader;
  16 import java.io.StringBufferInputStream;
  17
  18 import java.sql.Clob;
  19 import java.sql.Blob;
  20 import java.sql.Ref;
  21 import java.sql.Array;
  22 import java.sql.Types;
  23
  24 import java.sql.RowId;
  25 import java.sql.SQLXML;
  26 import java.io.Reader;
  27 import java.sql.NClob;
  28 import java.sql.Wrapper;
  29
  30 public class JdbcSqlResultSet extends JSqlError implements ResultSet, JSqlErrorType
  31 {
  32     public JdbcSqlStatement stmt; // This guy creates me
  33     public JdbcSqlResultSetMetaData rsmd;
  34
  35     public boolean closedFlag;
  36     long curRow;
  37     int pos=0;
  38
  39     private java.util.ArrayList rows;
  40     private FieldInfo[] fields;
  41     private int[] srcBindType;
  42     private boolean shouldDriverHandle;
  43     int totalField;
  44     JdbcSqlResultSet()
  45     {
  46         rsmd = new JdbcSqlResultSetMetaData();
  47         closedFlag = false;
  48         curRow = -1;
  49         shouldDriverHandle = false ;
  50     }
  51     void setProjField(){
  52         srcBindType = stmt.jniStmt.getProjFldTypeArray();
  53     }
  54
  55     void setStmt( JdbcSqlStatement jdbcStmt )
  56     {
  57         stmt = jdbcStmt;
  58         rsmd.setStmt( jdbcStmt );
  59         closedFlag = false;
  60         curRow = -1;
  61     }
  62
  63     JdbcSqlResultSet(FieldInfo[] field, java.util.ArrayList row)
  64     {
  65          closedFlag = false;
  66          curRow = -1;
  67          shouldDriverHandle = true ;
  68          this.fields = field;
  69          this.rows = row;
  70          rsmd = new JdbcSqlResultSetMetaData(field);
  71     }
  72     protected void finalize ()
  73     {
  74         try
  75         {
  76             if(!closedFlag) close();
  77         }
  78         catch(SQLException e)
  79         {
  80             System.out.println(e);
  81         }
  82     }
  83
  84     // API's
  85     public void close() throws SQLException
  86     {
  87         if( closedFlag ) return;
  88
  89         closedFlag = true;
  90         curRow = -1;
  91         //rsmd.close(); //commented by praba
  92         //after close the app can reexecute.
  93         if (stmt != null) stmt.closeScan();
  94         return;
  95     }
  96
  97     // Move to next tuple
  98     public boolean next () throws SQLException
  99     {
 100         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 101
 102         if( shouldDriverHandle && (rows == null)) return( false );
 103
 104         if( 0 == stmt.jniStmt.next() )
 105         {
 106             curRow = -2;
 107             return( false );
 108         }
 109         curRow += 1;
 110
 111         return( true );
 112     }
 113     public ResultSetMetaData getMetaData () throws SQLException
 114     {
 115         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 116         return( rsmd );
 117     }
 118     public SQLWarning getWarnings() throws SQLException
 119     {
 120         return( null );
 121     }
 122     public void clearWarnings() throws SQLException
 123     {
 124         return;
 125     }
 126     public int findColumn (String colName) throws SQLException
 127     {
 128         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 129
 130         int colnum = stmt.jniStmt.findColumn( colName );
 131         return( colnum );
 132     }
 133     public int getType() throws SQLException
 134     {
 135         return( ResultSet.TYPE_FORWARD_ONLY );
 136     }
 137     public int getConcurrency() throws SQLException
 138     {
 139         return( ResultSet.CONCUR_READ_ONLY );
 140     }
 141     public Statement getStatement() throws SQLException
 142     {
 143         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 144         return( stmt );
 145     }
 146     public boolean isFirst() throws SQLException
 147     {
 148         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 149
 150         if( curRow == 0 )
 151             return( true );
 152
 153         return( false );
 154     }
 155     public boolean isBeforeFirst() throws SQLException
 156     {
 157         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 158
 159         if( curRow == -1 )
 160             return( true );
 161
 162         return( false );
 163     }
 164     public boolean isAfterLast() throws SQLException
 165     {
 166         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 167
 168         if( curRow == -2 )
 169             return( true );
 170
 171         return( false );
 172     }
 173
 174     // Provide data to application
 175     // SHORT
 176     public short getShort (int colNum ) throws SQLException
 177     {
 178         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 179
 180         short out = stmt.jniStmt.getShort( colNum - 1, srcBindType[colNum] );
 181         if( false ) throw new SQLException();
 182         pos = colNum;
 183         return out;
 184     }
 185     public short getShort (String colName ) throws SQLException
 186     {
 187         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 188
 189         short out = stmt.jniStmt.getShortS( colName );
 190         if( false ) throw new SQLException();
 191         //pos = colNum;
 192         return out;
 193
 194     }
 195
 196     // INTEGER
 197     public int getInt (int colNum ) throws SQLException
 198     {
 199         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 200         int out = stmt.jniStmt.getInt( colNum - 1 , srcBindType[colNum]);
 201         if( false ) throw new SQLException();
 202         pos = colNum;
 203         return out;
 204     }
 205     public int getInt (String colName) throws SQLException
 206     {
 207        if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 208        int out = stmt.jniStmt.getIntS( colName );
 209        if( false ) throw new SQLException();
 210        return out;
 211     }
 212
 213     // LONG
 214     public long getLong (int colNum) throws SQLException
 215     {
 216         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 217         long out = stmt.jniStmt.getLong( colNum-1,srcBindType[colNum] );
 218         if( false ) throw new SQLException();
 219         pos = colNum;
 220         return out;
 221     }
 222     public long getLong (String colName) throws SQLException
 223     {
 224         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 225         long out = stmt.jniStmt.getLongS( colName );
 226         if( false ) throw new SQLException();
 227         //pos = colNum;
 228         return out;
 229     }
 230
 231     // BYTE
 232     public byte getByte (int colNum) throws SQLException
 233     {
 234         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 235
 236         byte out = stmt.jniStmt.getByte( colNum-1, srcBindType[colNum] );
 237         if( false ) throw new SQLException();
 238         pos = colNum;
 239         return out;
 240     }
 241     public byte getByte (String colName) throws SQLException
 242     {
 243         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 244         byte out = stmt.jniStmt.getByteS( colName );
 245         if( false ) throw new SQLException();
 246        // pos = colNum;
 247         return out;
 248
 249     }
 250
 251     // FLOAT
 252     public float getFloat (int colNum) throws SQLException
 253     {
 254         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 255
 256         float out = stmt.jniStmt.getFloat( colNum-1, srcBindType[colNum] );
 257         if( false ) throw new SQLException();
 258         pos = colNum;
 259         return out;
 260     }
 261     public float getFloat (String colName) throws SQLException
 262     {
 263         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 264         float out = stmt.jniStmt.getFloatS( colName );
 265         if( false ) throw new SQLException();
 266         //pos = colNum;
 267         return out;
 268
 269     }
 270
 271     // DOUBLE
 272     public double getDouble (int colNum) throws SQLException
 273     {
 274         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 275
 276         double out = stmt.jniStmt.getDouble( colNum-1, srcBindType[colNum] );
 277         if( false ) throw new SQLException();
 278        // pos = colNum;
 279         return out;
 280     }
 281     public double getDouble (String colName) throws SQLException
 282     {
 283        if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 284        double out = stmt.jniStmt.getDoubleS( colName );
 285        if( false ) throw new SQLException();
 286        //pos = colNum;
 287        return out;
 288
 289     }
 290
 291     // DECIMAL
 292     public BigDecimal getBigDecimal( int colNum )
 293        throws SQLException
 294     {
 295         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 296
 297         throw getException( CSQL_NOT_SUPPORTED );
 298
 299         // TODO
 300         // BigDecimal out = new BigDecimal( stmt.jniStmt.getBigDecimal( colNum-1 ) );
 301         //return out;
 302     }
 303     public BigDecimal getBigDecimal(String colName)
 304        throws SQLException
 305     {
 306         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 307         return( getBigDecimal( findColumn( colName ) ) );
 308     }
 309     public BigDecimal getBigDecimal (int colNum, int scale)
 310         throws SQLException
 311     {
 312         return( getBigDecimal( colNum ) );
 313     }
 314     public BigDecimal getBigDecimal (String colName, int scale)
 315         throws SQLException
 316     {
 317         return( getBigDecimal( colName ) );
 318     }
 319
 320     // STRING/VARSTRING
 321     public String getString(int colNum) throws SQLException
 322     {
 323         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 324
 325         // Get value
 326         String out = stmt.jniStmt.getString( colNum-1,srcBindType[colNum] );
 327         pos = colNum;
 328         return out;
 329     }
 330     public String getString (String colName) throws SQLException
 331     {
 332         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 333         String out = stmt.jniStmt.getStringS( colName );
 334        // pos = colNum;
 335         return out;
 336     }
 337     public InputStream getAsciiStream(int colNum) throws SQLException
 338     {
 339         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 340
 341         String out = stmt.jniStmt.getString( colNum-1, srcBindType[colNum]);
 342         pos = colNum;
 343         return( new StringBufferInputStream( out ) );
 344     }
 345     public java.io.InputStream getAsciiStream (String colName) throws SQLException
 346     {
 347         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 348
 349         String out = stmt.jniStmt.getStringS( colName );
 350         //pos = colNum;
 351         return( new StringBufferInputStream( out ) );
 352     }
 353     public java.io.Reader getCharacterStream(int colNum)
 354        throws SQLException
 355     {
 356         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 357
 358         InputStream iS = getAsciiStream( colNum );
 359         if( iS == null )
 360             return( null );
 361         pos = colNum;
 362         return( new InputStreamReader( iS ) );
 363     }
 364     public java.io.Reader getCharacterStream(String colName)
 365        throws SQLException
 366     {
 367         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 368
 369         InputStream iS = getAsciiStream( colName );
 370         if( iS == null )
 371             return( null );
 372         //pos = colNum;
 373         return( new InputStreamReader( iS ) );
 374
 375     }
 376
 377     // BOOLEAN
 378     public boolean getBoolean (int colNum) throws SQLException
 379     {
 380         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 381
 382         boolean out = stmt.jniStmt.getBoolean( colNum-1,srcBindType[colNum] );
 383         pos = colNum;
 384         return out;
 385     }
 386     public boolean getBoolean (String colName) throws SQLException
 387     {
 388        if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 389
 390         boolean out = stmt.jniStmt.getBooleanS( colName );
 391         //pos = colNum;
 392         return out;
 393
 394     }
 395
 396     // BINARY/VARBINARY
 397         public byte [] getBytes(int colNum) throws SQLException
 398     {
 399         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 400
 401         throw getException( CSQL_NOT_SUPPORTED );
 402         //byte[] out = stmt.jniStmt.getBytes( colNum-1 );
 403         //return out;
 404     }
 405     public byte[] getBytes (String colName) throws SQLException
 406     {
 407         return( getBytes( findColumn( colName ) ) );
 408     }
 409
 410     // DATE
 411     public java.sql.Date getDate (int colNum) throws SQLException
 412     {
 413         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 414
 415         java.sql.Date out = stmt.jniStmt.getDate( colNum-1,srcBindType[colNum] );
 416         pos = colNum;
 417         return out;
 418     }
 419     public java.sql.Date getDate(int colNum, java.util.Calendar cal)
 420        throws SQLException
 421     {
 422         return( getDate( colNum ) );
 423     }
 424     public java.sql.Date getDate (String colNum) throws SQLException
 425     {
 426          if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 427         java.sql.Date out = stmt.jniStmt.getDateS( colNum );
 428         //pos = colNum;
 429         return out;
 430     }
 431     public java.sql.Date getDate(String colName, java.util.Calendar cal)
 432        throws SQLException
 433     {
 434         return( getDate( colName ) );
 435     }
 436
 437     // TIME
 438     public java.sql.Time getTime (int colNum) throws SQLException
 439     {
 440         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 441
 442         // Get value
 443         java.sql.Time out = stmt.jniStmt.getTime( colNum-1, srcBindType[colNum] );
 444         pos = colNum;
 445         return out;
 446     }
 447     public java.sql.Time getTime(int colNum, java.util.Calendar cal)
 448        throws SQLException
 449     {
 450         return( getTime( colNum ) );
 451     }
 452     public java.sql.Time getTime (String colName) throws SQLException
 453     {
 454         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 455         java.sql.Time out = stmt.jniStmt.getTimeS( colName );
 456         //pos = colNum;
 457         return out;
 458
 459     }
 460     public java.sql.Time getTime(String colName, java.util.Calendar cal)
 461        throws SQLException
 462     {
 463         return( getTime( colName ) );
 464     }
 465
 466     // TIMESTAMP
 467     public java.sql.Timestamp getTimestamp (int colNum)
 468         throws SQLException
 469     {
 470         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 471
 472         java.sql.Timestamp out = stmt.jniStmt.getTimestamp( colNum-1, srcBindType[colNum] );
 473         pos = colNum;
 474         return out;
 475     }
 476     public java.sql.Timestamp getTimestamp(int colNum,
 477        java.util.Calendar cal) throws SQLException
 478     {
 479         return( getTimestamp( colNum ) );
 480     }
 481     public java.sql.Timestamp getTimestamp (String colName)
 482         throws SQLException
 483     {
 484         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 485
 486         java.sql.Timestamp out = stmt.jniStmt.getTimestampS( colName );
 487        // pos = colNum;
 488         return out;
 489
 490     }
 491     public java.sql.Timestamp getTimestamp(String colName,
 492        java.util.Calendar cal) throws SQLException
 493     {
 494         return( getTimestamp( colName ) );
 495     }
 496
 497     public Object getObject(int colNum) throws SQLException
 498     {
 499         Object obj = new String("no obj");
 500
 501         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 502
 503         switch ( rsmd.getColumnType( colNum ) )
 504         {
 505             case Types.DOUBLE:
 506                 obj = new Double( getDouble( colNum ) ); break;
 507             case Types.FLOAT:
 508                 obj = new Float( getFloat( colNum ) ); break;
 509             case Types.DECIMAL:
 510             case Types.NUMERIC:
 511                 obj = getBigDecimal( colNum ); break;
 512
 513             case Types.BIGINT:
 514                 obj = new Long( getLong( colNum ) ); break;
 515             case Types.INTEGER:
 516                 obj = new Integer( getInt( colNum ) ); break;
 517             case Types.SMALLINT:
 518                 obj = new Short( getShort( colNum ) ); break;
 519             case Types.TINYINT:
 520                 obj = new Byte( getByte( colNum ) ); break;
 521             case Types.BIT:
 522                 obj = new Boolean( getBoolean( colNum ) ); break;
 523
 524             case Types.DATE:
 525                 obj = getDate( colNum ); break;
 526             case Types.TIME:
 527                 obj = getTime( colNum ); break;
 528             case Types.TIMESTAMP:
 529                 obj = getTimestamp( colNum ); break;
 530
 531             case Types.CHAR:
 532                 obj = getString( colNum ); break;
 533             case Types.VARCHAR:
 534                 obj = getString( colNum ); break;
 535             case Types.BINARY:
 536             case Types.VARBINARY:
 537                 obj = getBytes( colNum ); break;
 538
 539             default: throw getException( CSQL_INVALID_DATATYPE );
 540         }
 541         // Return null if value read is null //TODO
 542         //if( wasNull() )
 543         //    return( null );
 544         pos = colNum;
 545         return( obj );
 546     }
 547     public Object getObject (String colName) throws SQLException
 548     {
 549         Object obj = new String("no obj");
 550
 551         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 552
 553         switch ( rsmd.getColumnType( findColumn (colName)) )
 554         {
 555             case Types.DOUBLE:
 556                 obj = new Double( getDouble( colName) ); break;
 557             case Types.FLOAT:
 558                 obj = new Float( getFloat( colName ) ); break;
 559             case Types.DECIMAL:
 560             case Types.NUMERIC:
 561                 obj = getBigDecimal( colName ); break;
 562             case Types.BIGINT:
 563                 obj = new Long( getLong( colName ) ); break;
 564             case Types.INTEGER:
 565                 obj = new Integer( getInt( colName ) ); break;
 566             case Types.SMALLINT:
 567                 obj = new Short( getShort( colName ) ); break;
 568             case Types.TINYINT:
 569                 obj = new Byte( getByte( colName ) ); break;
 570             case Types.BIT:
 571                 obj = new Boolean( getBoolean( colName ) ); break;
 572
 573             case Types.DATE:
 574                 obj = getDate( colName ); break;
 575             case Types.TIME:
 576                 obj = getTime( colName ); break;
 577             case Types.TIMESTAMP:
 578                 obj = getTimestamp( colName ); break;
 579
 580             case Types.CHAR:
 581                 obj = getString( colName ); break;
 582             case Types.VARCHAR:
 583                 obj = getString( colName ); break;
 584             case Types.BINARY:
 585             case Types.VARBINARY:
 586                 obj = getBytes( colName ); break;
 587
 588             default: throw getException( CSQL_INVALID_DATATYPE );
 589         }
 590 //        pos = colNum;
 591         return( obj );
 592
 593     }
 594     public Object getObject(int i, java.util.Map map) throws SQLException
 595     {
 596         return( getObject( i ) );
 597     }
 598     public Object getObject(String colName, java.util.Map map)
 599         throws SQLException
 600     {
 601         return( getObject( colName ) );
 602     }
 603
 604     public int getRow() throws SQLException
 605     {
 606         if( curRow < 0 )
 607             return( 0 );
 608
 609         return( (int) curRow + 1 );
 610     }
 611
 612     // UN-SUPPORTED API's
 613     public boolean wasNull () throws SQLException // TODO
 614     {
 615         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 616         return( stmt.jniStmt.isNull(pos) );
 617     }
 618     public String getCursorName () throws SQLException
 619     {
 620         throw getException( CSQL_NOT_SUPPORTED );
 621     }
 622     public boolean absolute( int row ) throws SQLException
 623     {
 624         throw getException( CSQL_NOT_SUPPORTED );
 625     }
 626     public void beforeFirst() throws SQLException
 627     {
 628         throw getException( CSQL_NOT_SUPPORTED );
 629     }
 630     public void afterLast() throws SQLException
 631     {
 632         throw getException( CSQL_NOT_SUPPORTED );
 633     }
 634     public boolean first() throws SQLException
 635     {
 636         throw getException( CSQL_NOT_SUPPORTED );
 637     }
 638     public boolean last() throws SQLException
 639     {
 640         throw getException( CSQL_NOT_SUPPORTED );
 641     }
 642     public boolean relative( int rows ) throws SQLException
 643     {
 644         throw getException( CSQL_NOT_SUPPORTED );
 645     }
 646     public boolean previous() throws SQLException
 647     {
 648         throw getException( CSQL_NOT_SUPPORTED );
 649     }
 650     public void setFetchDirection(int direction) throws SQLException
 651     {
 652         throw getException( CSQL_NOT_SUPPORTED );
 653     }
 654     public int getFetchDirection() throws SQLException
 655     {
 656         throw getException( CSQL_NOT_SUPPORTED );
 657     }
 658     public void setFetchSize(int rows) throws SQLException
 659     {
 660         throw getException( CSQL_NOT_SUPPORTED );
 661     }
 662     public int getFetchSize() throws SQLException
 663     {
 664         throw getException( CSQL_NOT_SUPPORTED );
 665     }
 666         public InputStream getUnicodeStream(int colNum) throws SQLException
 667     {
 668         throw getException( CSQL_NOT_SUPPORTED );
 669     }
 670         public InputStream getBinaryStream(int colNum) throws SQLException
 671     {
 672         throw getException( CSQL_NOT_SUPPORTED );
 673     }
 674     public java.io.InputStream getUnicodeStream (String colName) throws SQLException
 675     {
 676         throw getException( CSQL_NOT_SUPPORTED );
 677     }
 678     public java.io.InputStream getBinaryStream (String colName) throws SQLException
 679     {
 680         throw getException( CSQL_NOT_SUPPORTED );
 681     }
 682     public void setMaxRows(int maxRows) throws SQLException
 683     {
 684         throw getException( CSQL_NOT_SUPPORTED );
 685     }
 686     public void setMaxFieldSize(int maxFieldSize) throws SQLException
 687     {
 688         throw getException( CSQL_NOT_SUPPORTED );
 689     }
 690     public boolean rowUpdated() throws SQLException
 691     {
 692         throw getException( CSQL_NOT_SUPPORTED );
 693     }
 694     public boolean rowInserted() throws SQLException
 695     {
 696         throw getException( CSQL_NOT_SUPPORTED );
 697     }
 698     public boolean rowDeleted() throws SQLException
 699     {
 700         throw getException( CSQL_NOT_SUPPORTED );
 701     }
 702     public void updateNull(int colNum) throws SQLException
 703     {
 704         throw getException( CSQL_NOT_SUPPORTED );
 705     }
 706     public void updateBoolean(int colNum, boolean x) throws SQLException
 707     {
 708         throw getException( CSQL_NOT_SUPPORTED );
 709     }
 710     public void updateByte(int colNum, byte x) throws SQLException
 711     {
 712         throw getException( CSQL_NOT_SUPPORTED );
 713     }
 714     public void updateShort(int colNum, short x) throws SQLException
 715     {
 716         throw getException( CSQL_NOT_SUPPORTED );
 717     }
 718     public void updateInt(int colNum, int x) throws SQLException
 719     {
 720         throw getException( CSQL_NOT_SUPPORTED );
 721     }
 722     public void updateLong(int colNum, long x) throws SQLException
 723     {
 724         throw getException( CSQL_NOT_SUPPORTED );
 725     }
 726     public void updateFloat(int colNum, float x) throws SQLException
 727     {
 728         throw getException( CSQL_NOT_SUPPORTED );
 729     }
 730     public void updateDouble(int colNum, double x) throws SQLException
 731     {
 732         throw getException( CSQL_NOT_SUPPORTED );
 733     }
 734     public void updateBigDecimal(int colNum, BigDecimal x) throws SQLException
 735     {
 736         throw getException( CSQL_NOT_SUPPORTED );
 737     }
 738     public void updateString(int colNum, String x) throws SQLException
 739     {
 740         throw getException( CSQL_NOT_SUPPORTED );
 741     }
 742     public void updateBytes(int colNum, byte x[]) throws SQLException
 743     {
 744         throw getException( CSQL_NOT_SUPPORTED );
 745     }
 746     public void updateDate(int colNum, java.sql.Date x) throws SQLException
 747     {
 748         throw getException( CSQL_NOT_SUPPORTED );
 749     }
 750     public void updateTime(int colNum, java.sql.Time x) throws SQLException
 751     {
 752         throw getException( CSQL_NOT_SUPPORTED );
 753     }
 754     public void updateTimestamp(int colNum, java.sql.Timestamp x)
 755        throws SQLException
 756     {
 757         throw getException( CSQL_NOT_SUPPORTED );
 758     }
 759     public void updateAsciiStream(int colNum,
 760        java.io.InputStream x, int length) throws SQLException
 761     {
 762         throw getException( CSQL_NOT_SUPPORTED );
 763     }
 764     public void updateBinaryStream(int colNum,
 765        java.io.InputStream x, int length) throws SQLException
 766     {
 767         throw getException( CSQL_NOT_SUPPORTED );
 768     }
 769     public void updateCharacterStream(int colNum,
 770        java.io.Reader x, int length) throws SQLException
 771     {
 772         throw getException( CSQL_NOT_SUPPORTED );
 773     }
 774     public void updateNull(String colName) throws SQLException
 775     {
 776         throw getException( CSQL_NOT_SUPPORTED );
 777     }
 778     public void updateBoolean(String colName, boolean x) throws SQLException
 779     {
 780         throw getException( CSQL_NOT_SUPPORTED );
 781     }
 782     public void updateByte(String colName, byte x) throws SQLException
 783     {
 784         throw getException( CSQL_NOT_SUPPORTED );
 785     }
 786     public void updateShort(String colName, short x) throws SQLException
 787     {
 788         throw getException( CSQL_NOT_SUPPORTED );
 789     }
 790     public void updateInt(String colName, int x) throws SQLException
 791     {
 792         throw getException( CSQL_NOT_SUPPORTED );
 793     }
 794     public void updateLong(String colName, long x) throws SQLException
 795     {
 796         throw getException( CSQL_NOT_SUPPORTED );
 797     }
 798     public void updateFloat(String colName, float x) throws SQLException
 799     {
 800         throw getException( CSQL_NOT_SUPPORTED );
 801     }
 802     public void updateDouble(String colName, double x) throws SQLException
 803     {
 804         throw getException( CSQL_NOT_SUPPORTED );
 805     }
 806     public void updateBigDecimal(String colName, BigDecimal x)
 807         throws SQLException
 808     {
 809         throw getException( CSQL_NOT_SUPPORTED );
 810     }
 811     public void updateString(String colName, String x) throws SQLException
 812     {
 813         throw getException( CSQL_NOT_SUPPORTED );
 814     }
 815     public void updateBytes(String colName, byte x[]) throws SQLException
 816     {
 817         throw getException( CSQL_NOT_SUPPORTED );
 818     }
 819     public void updateDate(String colName, java.sql.Date x) throws SQLException
 820     {
 821         throw getException( CSQL_NOT_SUPPORTED );
 822     }
 823     public void updateTime(String colName, java.sql.Time x) throws SQLException
 824     {
 825         throw getException( CSQL_NOT_SUPPORTED );
 826     }
 827     public void updateTimestamp(String colName, java.sql.Timestamp x)
 828       throws SQLException
 829     {
 830         throw getException( CSQL_NOT_SUPPORTED );
 831     }
 832     public void updateAsciiStream(String colName,
 833       java.io.InputStream x, int length) throws SQLException
 834     {
 835         throw getException( CSQL_NOT_SUPPORTED );
 836     }
 837     public void updateBinaryStream(String colName,
 838       java.io.InputStream x, int length) throws SQLException
 839     {
 840         throw getException( CSQL_NOT_SUPPORTED );
 841     }
 842     public void updateCharacterStream(String colName,
 843       java.io.Reader reader, int length) throws SQLException
 844     {
 845         throw getException( CSQL_NOT_SUPPORTED );
 846     }
 847     public void updateObject(int colNum, Object x, int scale)
 848       throws SQLException
 849     {
 850         throw getException( CSQL_NOT_SUPPORTED );
 851     }
 852     public void updateObject(int colNum, Object x) throws SQLException
 853     {
 854         throw getException( CSQL_NOT_SUPPORTED );
 855     }
 856     public void insertRow() throws SQLException
 857     {
 858         throw getException( CSQL_NOT_SUPPORTED );
 859     }
 860     public void updateRow() throws SQLException
 861     {
 862         throw getException( CSQL_NOT_SUPPORTED );
 863     }
 864     public void deleteRow() throws SQLException
 865     {
 866         throw getException( CSQL_NOT_SUPPORTED );
 867     }
 868     public void refreshRow() throws SQLException
 869     {
 870         throw getException( CSQL_NOT_SUPPORTED );
 871     }
 872     public void cancelRowUpdates() throws SQLException
 873     {
 874         throw getException( CSQL_NOT_SUPPORTED );
 875     }
 876     public void moveToInsertRow() throws SQLException
 877     {
 878         throw getException( CSQL_NOT_SUPPORTED );
 879     }
 880     public void moveToCurrentRow() throws SQLException
 881     {
 882         throw getException( CSQL_NOT_SUPPORTED );
 883     }
 884     public Ref getRef(int i) throws SQLException
 885     {
 886         throw getException( CSQL_NOT_SUPPORTED );
 887     }
 888     public Blob getBlob(int i) throws SQLException
 889     {
 890         throw getException( CSQL_NOT_SUPPORTED );
 891     }
 892     public Clob getClob(int i) throws SQLException
 893     {
 894         throw getException( CSQL_NOT_SUPPORTED );
 895     }
 896     public Array getArray(int i) throws SQLException
 897     {
 898         throw getException( CSQL_NOT_SUPPORTED );
 899     }
 900     public Ref getRef(String colName) throws SQLException
 901     {
 902         throw getException( CSQL_NOT_SUPPORTED );
 903     }
 904     public Blob getBlob(String colName) throws SQLException
 905     {
 906         throw getException( CSQL_NOT_SUPPORTED );
 907     }
 908     public Clob getClob(String colName) throws SQLException
 909     {
 910         throw getException( CSQL_NOT_SUPPORTED );
 911     }
 912     public Array getArray(String colName) throws SQLException
 913     {
 914         throw getException( CSQL_NOT_SUPPORTED );
 915     }
 916     public    boolean isLast() throws SQLException
 917     {
 918         throw getException( CSQL_NOT_SUPPORTED );
 919     }
 920     public void updateObject(String colName, Object x) throws SQLException
 921     {
 922         throw getException( CSQL_NOT_SUPPORTED );
 923     }
 924     public    void updateObject(String colName, Object x, int scale)
 925                                                     throws SQLException
 926     {
 927         throw getException( CSQL_NOT_SUPPORTED );
 928     }
 929     public URL getURL(int colNum)
 930                         throws SQLException
 931     {
 932         throw getException( CSQL_NOT_SUPPORTED );
 933     }
 934     public URL getURL(String colName)
 935                         throws SQLException
 936     {
 937         throw getException( CSQL_NOT_SUPPORTED );
 938     }
 939     public void updateRef(int colNum, Ref x)
 940                         throws SQLException
 941     {
 942         throw getException( CSQL_NOT_SUPPORTED );
 943     }
 944     public void updateRef(String colName, Ref x)
 945                         throws SQLException
 946     {
 947         throw getException( CSQL_NOT_SUPPORTED );
 948     }
 949     public void updateBlob(int colNum, Blob x)
 950                          throws SQLException
 951     {
 952         throw getException( CSQL_NOT_SUPPORTED );
 953     }
 954     public void updateBlob(String colName, Blob x)
 955                          throws SQLException
 956     {
 957         throw getException( CSQL_NOT_SUPPORTED );
 958     }
 959     public void updateClob(int colNum, Clob x)
 960                          throws SQLException
 961     {
 962         throw getException( CSQL_NOT_SUPPORTED );
 963     }
 964     public void updateClob(String colName, Clob x)
 965                          throws SQLException
 966     {
 967         throw getException( CSQL_NOT_SUPPORTED );
 968     }
 969     public void updateArray(int colNum, Array x)
 970                           throws SQLException
 971     {
 972         throw getException( CSQL_NOT_SUPPORTED );
 973     }
 974     public void updateArray(String colName, Array x)
 975                           throws SQLException
 976     {
 977         throw getException( CSQL_NOT_SUPPORTED );
 978     }
 979     //java 1.6 methods
 980     public void updateRowId(int colIndex, RowId x)
 981                                              throws SQLException
 982     {
 983         throw getException( CSQL_NOT_SUPPORTED );
 984     }
 985     public void updateRowId(String colLabel, RowId x)
 986                                              throws SQLException
 987     {
 988         throw getException( CSQL_NOT_SUPPORTED );
 989     }
 990     public void updateSQLXML(int colIndex, SQLXML x)
 991                                              throws SQLException
 992     {
 993         throw getException( CSQL_NOT_SUPPORTED );
 994     }
 995     public void updateSQLXML(String colLabel, SQLXML x)
 996                                              throws SQLException
 997     {
 998         throw getException( CSQL_NOT_SUPPORTED );
 999     }
1000     public void updateNClob(int colIndex, NClob x)
1001                                              throws SQLException
1002     {
1003         throw getException( CSQL_NOT_SUPPORTED );
1004     }
1005     public void updateNClob(int colIndex, Reader x)
1006                                              throws SQLException
1007     {
1008         throw getException( CSQL_NOT_SUPPORTED );
1009     }
1010     public void updateNClob(int colIndex, Reader x, long length)
1011                                              throws SQLException
1012     {
1013         throw getException( CSQL_NOT_SUPPORTED );
1014     }
1015     public void updateNClob(String colIndex, NClob x)
1016                                              throws SQLException
1017     {
1018         throw getException( CSQL_NOT_SUPPORTED );
1019     }
1020     public void updateNClob(String colIndex, Reader x)
1021                                              throws SQLException
1022     {
1023         throw getException( CSQL_NOT_SUPPORTED );
1024     }
1025     public void updateNClob(String colIndex, Reader x, long length)
1026                                              throws SQLException
1027     {
1028         throw getException( CSQL_NOT_SUPPORTED );
1029     }
1030     public void updateNString(int colIndex, String x)
1031                                              throws SQLException
1032     {
1033         throw getException( CSQL_NOT_SUPPORTED );
1034     }
1035     public void updateNString(String colIndex, String x)
1036                                              throws SQLException
1037     {
1038         throw getException( CSQL_NOT_SUPPORTED );
1039     }
1040     public void updateNCharacterStream(int colIndex, Reader x)
1041                                              throws SQLException
1042     {
1043         throw getException( CSQL_NOT_SUPPORTED );
1044     }
1045     public void updateNCharacterStream(int colIndex, Reader x, long length)
1046                                              throws SQLException
1047     {
1048         throw getException( CSQL_NOT_SUPPORTED );
1049     }
1050     public void updateNCharacterStream(String colIndex, Reader x)
1051                                              throws SQLException
1052     {
1053         throw getException( CSQL_NOT_SUPPORTED );
1054     }
1055     public void updateNCharacterStream(String colIndex, Reader x, long length)
1056                                              throws SQLException
1057     {
1058         throw getException( CSQL_NOT_SUPPORTED );
1059     }
1060     public void updateCharacterStream(int colIndex, Reader x)
1061                                              throws SQLException
1062     {
1063         throw getException( CSQL_NOT_SUPPORTED );
1064     }
1065     public void updateCharacterStream(String colIndex, Reader x)
1066                                              throws SQLException
1067     {
1068         throw getException( CSQL_NOT_SUPPORTED );
1069     }
1070     public void updateCharacterStream(int colIndex, Reader x, long length)
1071                                              throws SQLException
1072     {
1073         throw getException( CSQL_NOT_SUPPORTED );
1074     }
1075     public void updateCharacterStream(String colIndex, Reader x, long length)
1076                                              throws SQLException
1077     {
1078         throw getException( CSQL_NOT_SUPPORTED );
1079     }
1080     public void updateBinaryStream(int colIndex, InputStream x)
1081                                              throws SQLException
1082     {
1083         throw getException( CSQL_NOT_SUPPORTED );
1084     }
1085     public void updateBinaryStream(String colIndex, InputStream x)
1086                                              throws SQLException
1087     {
1088         throw getException( CSQL_NOT_SUPPORTED );
1089     }
1090     public void updateBinaryStream(int colIndex, InputStream x, long length)
1091                                              throws SQLException
1092     {
1093         throw getException( CSQL_NOT_SUPPORTED );
1094     }
1095     public void updateBinaryStream(String colIndex, InputStream x, long length)
1096                                              throws SQLException
1097     {
1098         throw getException( CSQL_NOT_SUPPORTED );
1099     }
1100     public void updateAsciiStream(int colIndex, InputStream x)
1101                                              throws SQLException
1102     {
1103         throw getException( CSQL_NOT_SUPPORTED );
1104     }
1105     public void updateAsciiStream(String colIndex, InputStream x)
1106                                              throws SQLException
1107     {
1108         throw getException( CSQL_NOT_SUPPORTED );
1109     }
1110     public void updateAsciiStream(int colIndex, InputStream x, long length)
1111                                              throws SQLException
1112     {
1113         throw getException( CSQL_NOT_SUPPORTED );
1114     }
1115     public void updateAsciiStream(String colIndex, InputStream x, long length)
1116                                              throws SQLException
1117     {
1118         throw getException( CSQL_NOT_SUPPORTED );
1119     }
1120     public void updateClob(int colNum, Reader x) throws SQLException
1121     {
1122         throw getException( CSQL_NOT_SUPPORTED );
1123     }
1124     public void updateClob(String colNum, Reader x) throws SQLException
1125     {
1126         throw getException( CSQL_NOT_SUPPORTED );
1127     }
1128     public void updateClob(int colNum, Reader x, long length)
1129                                                   throws SQLException
1130     {
1131         throw getException( CSQL_NOT_SUPPORTED );
1132     }
1133     public void updateClob(String colNum, Reader x, long length)
1134                                                   throws SQLException
1135     {
1136         throw getException( CSQL_NOT_SUPPORTED );
1137     }
1138     public void updateBlob(int colNum, InputStream x) throws SQLException
1139     {
1140         throw getException( CSQL_NOT_SUPPORTED );
1141     }
1142     public void updateBlob(String colNum, InputStream x) throws SQLException
1143     {
1144         throw getException( CSQL_NOT_SUPPORTED );
1145     }
1146     public void updateBlob(int colNum, InputStream x, long length)
1147                                                     throws SQLException
1148     {
1149         throw getException( CSQL_NOT_SUPPORTED );
1150     }
1151     public void updateBlob(String colNum, InputStream x, long length)
1152                                                      throws SQLException
1153     {
1154         throw getException( CSQL_NOT_SUPPORTED );
1155     }
1156     public Reader getNCharacterStream(int colIndex) throws SQLException
1157     {
1158         throw getException( CSQL_NOT_SUPPORTED );
1159     }
1160     public Reader getNCharacterStream(String colLabel) throws SQLException
1161     {
1162         throw getException( CSQL_NOT_SUPPORTED );
1163     }
1164     public NClob getNClob(int colIndex) throws SQLException
1165     {
1166         throw getException( CSQL_NOT_SUPPORTED );
1167     }
1168     public NClob getNClob(String colLabel) throws SQLException
1169     {
1170         throw getException( CSQL_NOT_SUPPORTED );
1171     }
1172     public String getNString(int colIndex) throws SQLException
1173     {
1174         throw getException( CSQL_NOT_SUPPORTED );
1175     }
1176     public String getNString(String colLabel) throws SQLException
1177     {
1178         throw getException( CSQL_NOT_SUPPORTED );
1179     }
1180     public SQLXML getSQLXML(int colIndex) throws SQLException
1181     {
1182         throw getException(CSQL_NOT_SUPPORTED);
1183     }
1184     public SQLXML getSQLXML(String colLabel) throws SQLException
1185     {
1186         throw getException(CSQL_NOT_SUPPORTED);
1187     }
1188     public boolean isClosed()
1189     {
1190         return closedFlag;
1191     }
1192     public int getHoldability() throws SQLException
1193     {
1194         throw getException(CSQL_NOT_SUPPORTED);
1195     }
1196     public RowId getRowId(int val) throws SQLException
1197     {
1198         throw getException(CSQL_NOT_SUPPORTED);
1199     }
1200     public RowId getRowId(String val) throws SQLException
1201     {
1202         throw getException(CSQL_NOT_SUPPORTED);
1203     }
1204     public boolean isWrapperFor(Class ifact) throws SQLException
1205     {
1206         throw getException(CSQL_NOT_SUPPORTED);
1207     }
1208     public Class unwrap(Class iface) throws SQLException
1209     {
1210         throw getException(CSQL_NOT_SUPPORTED);
1211     }
1212 }