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 public class JdbcSqlResultSet extends JSqlError implements ResultSet, JSqlErrorType
  25 {
  26     public JdbcSqlStatement stmt; // This guy creates me
  27     public JdbcSqlResultSetMetaData rsmd;
  28
  29     public boolean isClosed;
  30     long curRow;
  31
  32
  33     JdbcSqlResultSet()
  34     {
  35         rsmd = new JdbcSqlResultSetMetaData();
  36         isClosed = false;
  37         curRow = -1;
  38     }
  39     void setStmt( JdbcSqlStatement jdbcStmt )
  40     {
  41         stmt = jdbcStmt;
  42         rsmd.setStmt( jdbcStmt );
  43         isClosed = false;
  44         curRow = -1;
  45     }
  46     protected void finalize ()
  47     {
  48         try
  49         {
  50             if(!isClosed) close();
  51         }
  52         catch(SQLException e)
  53         {
  54             System.out.println(e);
  55         }
  56     }
  57
  58     // API's
  59     public void close() throws SQLException
  60     {
  61         if( isClosed ) return;
  62
  63         isClosed = true;
  64         curRow = -1;
  65         //rsmd.close(); //commented by praba
  66         //after close the app can reexecute.
  67         if (stmt != null) stmt.closeScan();
  68         return;
  69     }
  70
  71     // Move to next tuple
  72     public boolean next () throws SQLException
  73     {
  74         if( isClosed ) throw getException( CSQL_INVALID_STATE );
  75
  76         if( 0 == stmt.jniStmt.next() )
  77         {
  78             curRow = -2;
  79             return( false );
  80         }
  81         curRow += 1;
  82
  83         return( true );
  84     }
  85     public ResultSetMetaData getMetaData () throws SQLException
  86     {
  87         if( isClosed ) throw getException( CSQL_INVALID_STATE );
  88         return( rsmd );
  89     }
  90     public SQLWarning getWarnings() throws SQLException
  91     {
  92         return( null );
  93     }
  94     public void clearWarnings() throws SQLException
  95     {
  96         return;
  97     }
  98     public int findColumn (String colName) throws SQLException
  99     {
 100         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 101
 102         int colnum = stmt.jniStmt.findColumn( colName );
 103         return( colnum );
 104     }
 105     public int getType() throws SQLException
 106     {
 107         return( ResultSet.TYPE_FORWARD_ONLY );
 108     }
 109     public int getConcurrency() throws SQLException
 110     {
 111         return( ResultSet.CONCUR_READ_ONLY );
 112     }
 113     public Statement getStatement() throws SQLException
 114     {
 115         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 116         return( stmt );
 117     }
 118     public boolean isFirst() throws SQLException
 119     {
 120         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 121
 122         if( curRow == 0 )
 123             return( true );
 124
 125         return( false );
 126     }
 127     public boolean isBeforeFirst() throws SQLException
 128     {
 129         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 130
 131         if( curRow == -1 )
 132             return( true );
 133
 134         return( false );
 135     }
 136     public boolean isAfterLast() throws SQLException
 137     {
 138         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 139
 140         if( curRow == -2 )
 141             return( true );
 142
 143         return( false );
 144     }
 145
 146     // Provide data to application
 147     // SHORT
 148     public short getShort (int colNum ) throws SQLException
 149     {
 150         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 151
 152         short out = stmt.jniStmt.getShort( colNum - 1 );
 153         if( false ) throw new SQLException();
 154         return out;
 155     }
 156     public short getShort (String colName ) throws SQLException
 157     {
 158         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 159         return( getShort( findColumn( colName ) ) );
 160     }
 161
 162     // INTEGER
 163     public int getInt (int colNum ) throws SQLException
 164     {
 165         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 166
 167         int out = stmt.jniStmt.getInt( colNum - 1 );
 168         if( false ) throw new SQLException();
 169         return out;
 170     }
 171     public int getInt (String colName) throws SQLException
 172     {
 173         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 174         return( getInt( findColumn( colName ) ) );
 175     }
 176
 177     // LONG
 178     public long getLong (int colNum) throws SQLException
 179     {
 180         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 181
 182         long out = stmt.jniStmt.getLong( colNum-1 );
 183         if( false ) throw new SQLException();
 184         return out;
 185     }
 186     public long getLong (String colName) throws SQLException
 187     {
 188         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 189         return( getLong( findColumn( colName ) ) );
 190     }
 191
 192     // BYTE
 193     public byte getByte (int colNum) throws SQLException
 194     {
 195         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 196
 197         byte out = stmt.jniStmt.getByte( colNum-1 );
 198         if( false ) throw new SQLException();
 199         return out;
 200     }
 201     public byte getByte (String colName) throws SQLException
 202     {
 203         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 204         return( getByte( findColumn( colName ) ) );
 205     }
 206
 207     // FLOAT
 208     public float getFloat (int colNum) throws SQLException
 209     {
 210         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 211
 212         float out = stmt.jniStmt.getFloat( colNum-1 );
 213         if( false ) throw new SQLException();
 214         return out;
 215     }
 216     public float getFloat (String colName) throws SQLException
 217     {
 218         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 219         return( getFloat( findColumn( colName ) ) );
 220     }
 221
 222     // DOUBLE
 223     public double getDouble (int colNum) throws SQLException
 224     {
 225         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 226
 227         double out = stmt.jniStmt.getDouble( colNum-1 );
 228         if( false ) throw new SQLException();
 229         return out;
 230     }
 231     public double getDouble (String colName) throws SQLException
 232     {
 233         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 234         return( getDouble( findColumn( colName ) ) );
 235     }
 236
 237     // DECIMAL
 238     public BigDecimal getBigDecimal( int colNum )
 239        throws SQLException
 240     {
 241         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 242
 243         throw getException( CSQL_NOT_SUPPORTED );
 244
 245         // TODO
 246         // BigDecimal out = new BigDecimal( stmt.jniStmt.getBigDecimal( colNum-1 ) );
 247         //return out;
 248     }
 249     public BigDecimal getBigDecimal(String colName)
 250        throws SQLException
 251     {
 252         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 253         return( getBigDecimal( findColumn( colName ) ) );
 254     }
 255     public BigDecimal getBigDecimal (int colNum, int scale)
 256         throws SQLException
 257     {
 258         return( getBigDecimal( colNum ) );
 259     }
 260     public BigDecimal getBigDecimal (String colName, int scale)
 261         throws SQLException
 262     {
 263         return( getBigDecimal( colName ) );
 264     }
 265
 266     // STRING/VARSTRING
 267     public String getString(int colNum) throws SQLException
 268     {
 269         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 270
 271         // Get value
 272         String out = stmt.jniStmt.getString( colNum-1 );
 273
 274         return out;
 275     }
 276     public String getString (String colName) throws SQLException
 277     {
 278         return( getString( findColumn( colName ) ) );
 279     }
 280     public InputStream getAsciiStream(int colNum) throws SQLException
 281     {
 282         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 283
 284         String out = stmt.jniStmt.getString( colNum-1 );
 285
 286         return( new StringBufferInputStream( out ) );
 287     }
 288     public java.io.InputStream getAsciiStream (String colName) throws SQLException
 289     {
 290         return( getAsciiStream( findColumn( colName ) ) );
 291     }
 292     public java.io.Reader getCharacterStream(int colNum)
 293        throws SQLException
 294     {
 295         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 296
 297         InputStream iS = getAsciiStream( colNum );
 298         if( iS == null )
 299             return( null );
 300
 301         return( new InputStreamReader( iS ) );
 302     }
 303     public java.io.Reader getCharacterStream(String colName)
 304        throws SQLException
 305     {
 306         return( getCharacterStream( findColumn( colName ) ) );
 307     }
 308
 309     // BOOLEAN
 310     public boolean getBoolean (int colNum) throws SQLException
 311     {
 312         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 313
 314         boolean out = stmt.jniStmt.getBoolean( colNum-1 );
 315
 316         return out;
 317     }
 318     public boolean getBoolean (String colName) throws SQLException
 319     {
 320         return( getBoolean( findColumn( colName ) ) );
 321     }
 322
 323     // BINARY/VARBINARY
 324         public byte [] getBytes(int colNum) throws SQLException
 325     {
 326         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 327
 328         throw getException( CSQL_NOT_SUPPORTED );
 329         //byte[] out = stmt.jniStmt.getBytes( colNum-1 );
 330         //return out;
 331     }
 332     public byte[] getBytes (String colName) throws SQLException
 333     {
 334         return( getBytes( findColumn( colName ) ) );
 335     }
 336
 337     // DATE
 338     public java.sql.Date getDate (int colNum) throws SQLException
 339     {
 340         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 341
 342         java.sql.Date out = stmt.jniStmt.getDate( colNum-1 );
 343
 344         return out;
 345     }
 346     public java.sql.Date getDate(int colNum, java.util.Calendar cal)
 347        throws SQLException
 348     {
 349         return( getDate( colNum ) );
 350     }
 351     public java.sql.Date getDate (String colNum) throws SQLException
 352     {
 353         return( getDate( findColumn( colNum ) ) );
 354     }
 355     public java.sql.Date getDate(String colName, java.util.Calendar cal)
 356        throws SQLException
 357     {
 358         return( getDate( colName ) );
 359     }
 360
 361     // TIME
 362     public java.sql.Time getTime (int colNum) throws SQLException
 363     {
 364         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 365
 366         // Get value
 367         java.sql.Time out = stmt.jniStmt.getTime( colNum-1 );
 368
 369         return out;
 370     }
 371     public java.sql.Time getTime(int colNum, java.util.Calendar cal)
 372        throws SQLException
 373     {
 374         return( getTime( colNum ) );
 375     }
 376     public java.sql.Time getTime (String colName) throws SQLException
 377     {
 378         return( getTime( findColumn( colName ) ) );
 379     }
 380     public java.sql.Time getTime(String colName, java.util.Calendar cal)
 381        throws SQLException
 382     {
 383         return( getTime( colName ) );
 384     }
 385
 386     // TIMESTAMP
 387     public java.sql.Timestamp getTimestamp (int colNum)
 388         throws SQLException
 389     {
 390         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 391
 392         java.sql.Timestamp out = stmt.jniStmt.getTimestamp( colNum-1 );
 393
 394         return out;
 395     }
 396     public java.sql.Timestamp getTimestamp(int colNum,
 397        java.util.Calendar cal) throws SQLException
 398     {
 399         return( getTimestamp( colNum ) );
 400     }
 401     public java.sql.Timestamp getTimestamp (String colName)
 402         throws SQLException
 403     {
 404         return( getTimestamp( findColumn( colName ) ) );
 405     }
 406     public java.sql.Timestamp getTimestamp(String colName,
 407        java.util.Calendar cal) throws SQLException
 408     {
 409         return( getTimestamp( colName ) );
 410     }
 411
 412     public Object getObject(int colNum) throws SQLException
 413     {
 414         Object obj = new String("no obj");
 415
 416         if( isClosed || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 417
 418         switch ( rsmd.getColumnType( colNum ) )
 419         {
 420             case Types.DOUBLE:
 421                 obj = new Double( getDouble( colNum ) ); break;
 422             case Types.FLOAT:
 423                 obj = new Float( getFloat( colNum ) ); break;
 424             case Types.DECIMAL:
 425             case Types.NUMERIC:
 426                 obj = getBigDecimal( colNum ); break;
 427
 428             case Types.BIGINT:
 429                 obj = new Long( getLong( colNum ) ); break;
 430             case Types.INTEGER:
 431                 obj = new Integer( getInt( colNum ) ); break;
 432             case Types.SMALLINT:
 433                 obj = new Short( getShort( colNum ) ); break;
 434             case Types.TINYINT:
 435                 obj = new Byte( getByte( colNum ) ); break;
 436             case Types.BIT:
 437                 obj = new Boolean( getBoolean( colNum ) ); break;
 438
 439             case Types.DATE:
 440                 obj = getDate( colNum ); break;
 441             case Types.TIME:
 442                 obj = getTime( colNum ); break;
 443             case Types.TIMESTAMP:
 444                 obj = getTimestamp( colNum ); break;
 445
 446             case Types.CHAR:
 447                 obj = getString( colNum ); break;
 448             case Types.VARCHAR:
 449                 obj = getString( colNum ); break;
 450             case Types.BINARY:
 451             case Types.VARBINARY:
 452                 obj = getBytes( colNum ); break;
 453
 454             default: throw getException( CSQL_INVALID_DATATYPE );
 455         }
 456         // Return null if value read is null //TODO
 457         //if( wasNull() )
 458         //    return( null );
 459
 460         return( obj );
 461     }
 462     public Object getObject (String colName) throws SQLException
 463     {
 464         return( getObject( findColumn( colName ) ) );
 465     }
 466     public Object getObject(int i, java.util.Map map) throws SQLException
 467     {
 468         return( getObject( i ) );
 469     }
 470     public Object getObject(String colName, java.util.Map map)
 471         throws SQLException
 472     {
 473         return( getObject( colName ) );
 474     }
 475
 476     public int getRow() throws SQLException
 477     {
 478         if( curRow < 0 )
 479             return( 0 );
 480
 481         return( (int) curRow + 1 );
 482     }
 483
 484     // UN-SUPPORTED API's
 485     public boolean wasNull () throws SQLException // TODO
 486     {
 487         if( isClosed ) throw getException( CSQL_INVALID_STATE );
 488         throw getException( CSQL_NOT_SUPPORTED );
 489         //return( stmt.jniStmt.wasNull() );
 490     }
 491     public String getCursorName () throws SQLException
 492     {
 493         throw getException( CSQL_NOT_SUPPORTED );
 494     }
 495     public boolean absolute( int row ) throws SQLException
 496     {
 497         throw getException( CSQL_NOT_SUPPORTED );
 498     }
 499     public void beforeFirst() throws SQLException
 500     {
 501         throw getException( CSQL_NOT_SUPPORTED );
 502     }
 503     public void afterLast() throws SQLException
 504     {
 505         throw getException( CSQL_NOT_SUPPORTED );
 506     }
 507     public boolean first() throws SQLException
 508     {
 509         throw getException( CSQL_NOT_SUPPORTED );
 510     }
 511     public boolean last() throws SQLException
 512     {
 513         throw getException( CSQL_NOT_SUPPORTED );
 514     }
 515     public boolean relative( int rows ) throws SQLException
 516     {
 517         throw getException( CSQL_NOT_SUPPORTED );
 518     }
 519     public boolean previous() throws SQLException
 520     {
 521         throw getException( CSQL_NOT_SUPPORTED );
 522     }
 523     public void setFetchDirection(int direction) throws SQLException
 524     {
 525         throw getException( CSQL_NOT_SUPPORTED );
 526     }
 527     public int getFetchDirection() throws SQLException
 528     {
 529         throw getException( CSQL_NOT_SUPPORTED );
 530     }
 531     public void setFetchSize(int rows) throws SQLException
 532     {
 533         throw getException( CSQL_NOT_SUPPORTED );
 534     }
 535     public int getFetchSize() throws SQLException
 536     {
 537         throw getException( CSQL_NOT_SUPPORTED );
 538     }
 539         public InputStream getUnicodeStream(int colNum) throws SQLException
 540     {
 541         throw getException( CSQL_NOT_SUPPORTED );
 542     }
 543         public InputStream getBinaryStream(int colNum) throws SQLException
 544     {
 545         throw getException( CSQL_NOT_SUPPORTED );
 546     }
 547     public java.io.InputStream getUnicodeStream (String colName) throws SQLException
 548     {
 549         throw getException( CSQL_NOT_SUPPORTED );
 550     }
 551     public java.io.InputStream getBinaryStream (String colName) throws SQLException
 552     {
 553         throw getException( CSQL_NOT_SUPPORTED );
 554     }
 555     public void setMaxRows(int maxRows) throws SQLException
 556     {
 557         throw getException( CSQL_NOT_SUPPORTED );
 558     }
 559     public void setMaxFieldSize(int maxFieldSize) throws SQLException
 560     {
 561         throw getException( CSQL_NOT_SUPPORTED );
 562     }
 563     public boolean rowUpdated() throws SQLException
 564     {
 565         throw getException( CSQL_NOT_SUPPORTED );
 566     }
 567     public boolean rowInserted() throws SQLException
 568     {
 569         throw getException( CSQL_NOT_SUPPORTED );
 570     }
 571     public boolean rowDeleted() throws SQLException
 572     {
 573         throw getException( CSQL_NOT_SUPPORTED );
 574     }
 575     public void updateNull(int colNum) throws SQLException
 576     {
 577         throw getException( CSQL_NOT_SUPPORTED );
 578     }
 579     public void updateBoolean(int colNum, boolean x) throws SQLException
 580     {
 581         throw getException( CSQL_NOT_SUPPORTED );
 582     }
 583     public void updateByte(int colNum, byte x) throws SQLException
 584     {
 585         throw getException( CSQL_NOT_SUPPORTED );
 586     }
 587     public void updateShort(int colNum, short x) throws SQLException
 588     {
 589         throw getException( CSQL_NOT_SUPPORTED );
 590     }
 591     public void updateInt(int colNum, int x) throws SQLException
 592     {
 593         throw getException( CSQL_NOT_SUPPORTED );
 594     }
 595     public void updateLong(int colNum, long x) throws SQLException
 596     {
 597         throw getException( CSQL_NOT_SUPPORTED );
 598     }
 599     public void updateFloat(int colNum, float x) throws SQLException
 600     {
 601         throw getException( CSQL_NOT_SUPPORTED );
 602     }
 603     public void updateDouble(int colNum, double x) throws SQLException
 604     {
 605         throw getException( CSQL_NOT_SUPPORTED );
 606     }
 607     public void updateBigDecimal(int colNum, BigDecimal x) throws SQLException
 608     {
 609         throw getException( CSQL_NOT_SUPPORTED );
 610     }
 611     public void updateString(int colNum, String x) throws SQLException
 612     {
 613         throw getException( CSQL_NOT_SUPPORTED );
 614     }
 615     public void updateBytes(int colNum, byte x[]) throws SQLException
 616     {
 617         throw getException( CSQL_NOT_SUPPORTED );
 618     }
 619     public void updateDate(int colNum, java.sql.Date x) throws SQLException
 620     {
 621         throw getException( CSQL_NOT_SUPPORTED );
 622     }
 623     public void updateTime(int colNum, java.sql.Time x) throws SQLException
 624     {
 625         throw getException( CSQL_NOT_SUPPORTED );
 626     }
 627     public void updateTimestamp(int colNum, java.sql.Timestamp x)
 628        throws SQLException
 629     {
 630         throw getException( CSQL_NOT_SUPPORTED );
 631     }
 632     public void updateAsciiStream(int colNum,
 633        java.io.InputStream x, int length) throws SQLException
 634     {
 635         throw getException( CSQL_NOT_SUPPORTED );
 636     }
 637     public void updateBinaryStream(int colNum,
 638        java.io.InputStream x, int length) throws SQLException
 639     {
 640         throw getException( CSQL_NOT_SUPPORTED );
 641     }
 642     public void updateCharacterStream(int colNum,
 643        java.io.Reader x, int length) throws SQLException
 644     {
 645         throw getException( CSQL_NOT_SUPPORTED );
 646     }
 647     public void updateNull(String colName) throws SQLException
 648     {
 649         throw getException( CSQL_NOT_SUPPORTED );
 650     }
 651     public void updateBoolean(String colName, boolean x) throws SQLException
 652     {
 653         throw getException( CSQL_NOT_SUPPORTED );
 654     }
 655     public void updateByte(String colName, byte x) throws SQLException
 656     {
 657         throw getException( CSQL_NOT_SUPPORTED );
 658     }
 659     public void updateShort(String colName, short x) throws SQLException
 660     {
 661         throw getException( CSQL_NOT_SUPPORTED );
 662     }
 663     public void updateInt(String colName, int x) throws SQLException
 664     {
 665         throw getException( CSQL_NOT_SUPPORTED );
 666     }
 667     public void updateLong(String colName, long x) throws SQLException
 668     {
 669         throw getException( CSQL_NOT_SUPPORTED );
 670     }
 671     public void updateFloat(String colName, float x) throws SQLException
 672     {
 673         throw getException( CSQL_NOT_SUPPORTED );
 674     }
 675     public void updateDouble(String colName, double x) throws SQLException
 676     {
 677         throw getException( CSQL_NOT_SUPPORTED );
 678     }
 679     public void updateBigDecimal(String colName, BigDecimal x)
 680         throws SQLException
 681     {
 682         throw getException( CSQL_NOT_SUPPORTED );
 683     }
 684     public void updateString(String colName, String x) throws SQLException
 685     {
 686         throw getException( CSQL_NOT_SUPPORTED );
 687     }
 688     public void updateBytes(String colName, byte x[]) throws SQLException
 689     {
 690         throw getException( CSQL_NOT_SUPPORTED );
 691     }
 692     public void updateDate(String colName, java.sql.Date x) throws SQLException
 693     {
 694         throw getException( CSQL_NOT_SUPPORTED );
 695     }
 696     public void updateTime(String colName, java.sql.Time x) throws SQLException
 697     {
 698         throw getException( CSQL_NOT_SUPPORTED );
 699     }
 700     public void updateTimestamp(String colName, java.sql.Timestamp x)
 701       throws SQLException
 702     {
 703         throw getException( CSQL_NOT_SUPPORTED );
 704     }
 705     public void updateAsciiStream(String colName,
 706       java.io.InputStream x, int length) throws SQLException
 707     {
 708         throw getException( CSQL_NOT_SUPPORTED );
 709     }
 710     public void updateBinaryStream(String colName,
 711       java.io.InputStream x, int length) throws SQLException
 712     {
 713         throw getException( CSQL_NOT_SUPPORTED );
 714     }
 715     public void updateCharacterStream(String colName,
 716       java.io.Reader reader, int length) throws SQLException
 717     {
 718         throw getException( CSQL_NOT_SUPPORTED );
 719     }
 720     public void updateObject(int colNum, Object x, int scale)
 721       throws SQLException
 722     {
 723         throw getException( CSQL_NOT_SUPPORTED );
 724     }
 725     public void updateObject(int colNum, Object x) throws SQLException
 726     {
 727         throw getException( CSQL_NOT_SUPPORTED );
 728     }
 729     public void insertRow() throws SQLException
 730     {
 731         throw getException( CSQL_NOT_SUPPORTED );
 732     }
 733     public void updateRow() throws SQLException
 734     {
 735         throw getException( CSQL_NOT_SUPPORTED );
 736     }
 737     public void deleteRow() throws SQLException
 738     {
 739         throw getException( CSQL_NOT_SUPPORTED );
 740     }
 741     public void refreshRow() throws SQLException
 742     {
 743         throw getException( CSQL_NOT_SUPPORTED );
 744     }
 745     public void cancelRowUpdates() throws SQLException
 746     {
 747         throw getException( CSQL_NOT_SUPPORTED );
 748     }
 749     public void moveToInsertRow() throws SQLException
 750     {
 751         throw getException( CSQL_NOT_SUPPORTED );
 752     }
 753     public void moveToCurrentRow() throws SQLException
 754     {
 755         throw getException( CSQL_NOT_SUPPORTED );
 756     }
 757     public Ref getRef(int i) throws SQLException
 758     {
 759         throw getException( CSQL_NOT_SUPPORTED );
 760     }
 761     public Blob getBlob(int i) throws SQLException
 762     {
 763         throw getException( CSQL_NOT_SUPPORTED );
 764     }
 765     public Clob getClob(int i) throws SQLException
 766     {
 767         throw getException( CSQL_NOT_SUPPORTED );
 768     }
 769     public Array getArray(int i) throws SQLException
 770     {
 771         throw getException( CSQL_NOT_SUPPORTED );
 772     }
 773     public Ref getRef(String colName) throws SQLException
 774     {
 775         throw getException( CSQL_NOT_SUPPORTED );
 776     }
 777     public Blob getBlob(String colName) throws SQLException
 778     {
 779         throw getException( CSQL_NOT_SUPPORTED );
 780     }
 781     public Clob getClob(String colName) throws SQLException
 782     {
 783         throw getException( CSQL_NOT_SUPPORTED );
 784     }
 785     public Array getArray(String colName) throws SQLException
 786     {
 787         throw getException( CSQL_NOT_SUPPORTED );
 788     }
 789     public    boolean isLast() throws SQLException
 790     {
 791         throw getException( CSQL_NOT_SUPPORTED );
 792     }
 793     public void updateObject(String colName, Object x) throws SQLException
 794     {
 795         throw getException( CSQL_NOT_SUPPORTED );
 796     }
 797     public    void updateObject(String colName, Object x, int scale)
 798        throws SQLException
 799     {
 800         throw getException( CSQL_NOT_SUPPORTED );
 801     }
 802     public URL getURL(int colNum)
 803                         throws SQLException
 804     {
 805         throw getException( CSQL_NOT_SUPPORTED );
 806     }
 807     public URL getURL(String colName)
 808                         throws SQLException
 809     {
 810         throw getException( CSQL_NOT_SUPPORTED );
 811     }
 812     public void updateRef(int colNum, Ref x)
 813                         throws SQLException
 814     {
 815         throw getException( CSQL_NOT_SUPPORTED );
 816     }
 817     public void updateRef(String colName, Ref x)
 818                         throws SQLException
 819     {
 820         throw getException( CSQL_NOT_SUPPORTED );
 821     }
 822     public void updateBlob(int colNum, Blob x)
 823                          throws SQLException
 824     {
 825         throw getException( CSQL_NOT_SUPPORTED );
 826     }
 827     public void updateBlob(String colName, Blob x)
 828                          throws SQLException
 829     {
 830         throw getException( CSQL_NOT_SUPPORTED );
 831     }
 832     public void updateClob(int colNum, Clob x)
 833                          throws SQLException
 834     {
 835         throw getException( CSQL_NOT_SUPPORTED );
 836     }
 837     public void updateClob(String colName, Clob x)
 838                          throws SQLException
 839     {
 840         throw getException( CSQL_NOT_SUPPORTED );
 841     }
 842     public void updateArray(int colNum, Array x)
 843                           throws SQLException
 844     {
 845         throw getException( CSQL_NOT_SUPPORTED );
 846     }
 847     public void updateArray(String colName, Array x)
 848                           throws SQLException
 849     {
 850         throw getException( CSQL_NOT_SUPPORTED );
 851     }
 852 }