src/jdbc/JdbcSqlStatement.java

   1 package csql.jdbc;
   2 import java.sql.Connection;
   3 import java.sql.Statement;
   4 import java.sql.SQLException;
   5 import java.sql.ResultSet;
   6 import java.sql.SQLWarning;
   7
   8 public class JdbcSqlStatement extends JSqlError implements Statement, JSqlErrorType
   9 {
  10     public boolean closedFlag;
  11     public boolean isPrepared;
  12     public int rowsAffect;
  13     public JSqlStatement jniStmt;
  14     public JdbcSqlConnection conn;
  15     public JdbcSqlResultSet rs;
  16
  17     JdbcSqlStatement( Connection con )
  18     {
  19         jniStmt = new JSqlStatement();
  20         conn = (JdbcSqlConnection) con;
  21         jniStmt.alloc(conn.mode);
  22         jniStmt.setConnectionPtr( conn.getConnection().getPtr() );
  23         closedFlag = false;
  24         isPrepared = false;
  25         rowsAffect = 0;
  26         rs = new JdbcSqlResultSet();
  27     }
  28     protected void finalize ()
  29     {
  30         try
  31         {
  32             if(!closedFlag)
  33                 close();
  34             jniStmt.free();//praba
  35         }
  36         catch(SQLException e)
  37         {
  38             System.out.println(e);
  39         }
  40     }
  41     public void prepareInt(String query) throws SQLException
  42     {
  43         int rv = 0;
  44         if(isPrepared)
  45         {
  46             if(jniStmt.isSelect()) rs.close();
  47             jniStmt.freeStmt();
  48             isPrepared = false;
  49         }
  50         rv = jniStmt.prepare(query);
  51         if( rv != 0 ) // 0 ->OK
  52         {
  53             throw getException(CSQL_PREPARE_ERR);
  54         }
  55         isPrepared = true;
  56     }
  57     public boolean executeInt() throws SQLException
  58     {
  59         if (!isPrepared) throw getException(CSQL_NOT_PREPARED);
  60         boolean isSelect = jniStmt.isSelect();
  61         rowsAffect = jniStmt.execute();
  62         if( rowsAffect < 0 )
  63             throw getException(CSQL_EXECUTE_ERR);
  64         if(conn.getAutoCommit())
  65             conn.commit();
  66
  67         return(isSelect);
  68     }
  69
  70     public void close() throws SQLException
  71     {
  72         if(closedFlag) return;
  73         if(isPrepared)
  74         {
  75             if(jniStmt.isSelect() ) rs.close();
  76             jniStmt.freeStmt();
  77             //jniStmt.free(); Praba. this makes the stmt unusable after close
  78         }
  79         closedFlag = true;
  80         return;
  81     }
  82
  83     public void closeScan() throws SQLException
  84     {
  85         if( jniStmt.isSelect()) jniStmt.close();
  86     }
  87
  88     public boolean execute (String query) throws SQLException
  89     {
  90         prepareInt(query);
  91         return(executeInt());
  92     }
  93
  94     public ResultSet executeQuery(String query) throws SQLException
  95     {
  96         prepareInt(query);
  97         if( !jniStmt.isSelect() ) {
  98             jniStmt.freeStmt();
  99             isPrepared = false;
 100             throw getException(CSQL_NOT_QUERY);
 101         }
 102         boolean hasResult = executeInt();
 103
 104         rs.setStmt( this );
 105         return( rs );
 106     }
 107     public int executeUpdate (String query) throws SQLException
 108     {
 109         if(execute(query))
 110             throw getException(CSQL_NOT_UPDATE);
 111         return(rowsAffect);
 112     }
 113     public Connection getConnection() throws SQLException
 114     {
 115        return(conn);
 116     }
 117     public int getFetchDirection() throws SQLException
 118     {
 119         return(ResultSet.FETCH_FORWARD);
 120     }
 121     public int getFetchSize() throws SQLException
 122     {
 123         return 1;
 124     }
 125     public ResultSet getResultSet() throws SQLException
 126     {
 127         if(!jniStmt.isSelect())
 128             return (null);
 129          //praba:;changed this
 130          rs.setStmt(this);
 131          return rs;
 132     }
 133     public int getResultSetConcurrency() throws SQLException
 134     {
 135         return(ResultSet.CONCUR_READ_ONLY);
 136     }
 137     public int getResultSetHoldability() throws SQLException
 138     {
 139         return(ResultSet.CLOSE_CURSORS_AT_COMMIT);
 140     }
 141     public int getResultSetType()  throws SQLException
 142     {
 143         return(ResultSet.TYPE_FORWARD_ONLY);
 144     }
 145     public int getUpdateCount() throws SQLException
 146     {
 147         if(jniStmt.isSelect())
 148             return -1;
 149         return rowsAffect;
 150     }
 151
 152
 153     //Unsupported APIs
 154     public void addBatch(String sql) throws SQLException
 155     {
 156         throw getException(CSQL_NOT_SUPPORTED);
 157     }
 158     public void cancel() throws SQLException
 159     {
 160         throw getException(CSQL_NOT_SUPPORTED);
 161     }
 162     public void clearBatch() throws SQLException
 163     {
 164         throw getException(CSQL_NOT_SUPPORTED);
 165     }
 166     public void clearWarnings() throws SQLException
 167     {
 168         throw getException(CSQL_NOT_SUPPORTED);
 169     }
 170     public boolean execute(String sql, int autoGeneratedKeys) throws SQLException
 171     {
 172         throw getException(CSQL_NOT_SUPPORTED);
 173     }
 174     public boolean execute(String sql, int[] columnIndexes) throws SQLException
 175     {
 176         throw getException(CSQL_NOT_SUPPORTED);
 177     }
 178     public boolean execute(String sql, String[] columnNames) throws SQLException
 179     {
 180         throw getException(CSQL_NOT_SUPPORTED);
 181     }
 182     public int[] executeBatch() throws SQLException
 183     {
 184         throw getException(CSQL_NOT_SUPPORTED);
 185     }
 186     public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException
 187     {
 188         throw getException(CSQL_NOT_SUPPORTED);
 189     }
 190     public int executeUpdate(String sql, int[] columnIndexes) throws SQLException
 191     {
 192         throw getException(CSQL_NOT_SUPPORTED);
 193     }
 194     public int executeUpdate(String sql, String[] columnNames) throws SQLException
 195     {
 196         throw getException(CSQL_NOT_SUPPORTED);
 197     }
 198     public ResultSet getGeneratedKeys() throws SQLException
 199     {
 200         throw getException(CSQL_NOT_SUPPORTED);
 201     }
 202     public int getMaxFieldSize() throws SQLException
 203     {
 204         throw getException(CSQL_NOT_SUPPORTED);
 205     }
 206     public int getMaxRows() throws SQLException
 207     {
 208         throw getException(CSQL_NOT_SUPPORTED);
 209     }
 210     public boolean getMoreResults() throws SQLException
 211     {
 212         throw getException(CSQL_NOT_SUPPORTED);
 213     }
 214     public boolean getMoreResults( int current) throws SQLException
 215     {
 216         throw getException(CSQL_NOT_SUPPORTED);
 217     }
 218     public int getQueryTimeout() throws SQLException
 219     {
 220         throw getException(CSQL_NOT_SUPPORTED);
 221     }
 222     public SQLWarning getWarnings() throws SQLException
 223     {
 224         throw getException(CSQL_NOT_SUPPORTED);
 225     }
 226     public void setCursorName(String name) throws SQLException
 227     {
 228         throw getException(CSQL_NOT_SUPPORTED);
 229     }
 230     public void setEscapeProcessing(boolean enable) throws SQLException
 231     {
 232         throw getException(CSQL_NOT_SUPPORTED);
 233     }
 234     public void setFetchDirection(int direction) throws SQLException
 235     {
 236         throw getException(CSQL_NOT_SUPPORTED);
 237     }
 238     public void setFetchSize(int rows) throws SQLException
 239     {
 240         throw getException(CSQL_NOT_SUPPORTED);
 241     }
 242     public void setMaxFieldSize(int max) throws SQLException
 243     {
 244         throw getException(CSQL_NOT_SUPPORTED);
 245     }
 246     public void setMaxRows(int maxRows) throws SQLException
 247     {
 248         throw getException(CSQL_NOT_SUPPORTED);
 249     }
 250     public void setQueryTimeout(int seconds) throws SQLException
 251     {
 252         throw getException(CSQL_NOT_SUPPORTED);
 253     }
 254     //java 1.6 methods
 255     public boolean isPoolable()
 256     {
 257         return false;
 258     }
 259     public void setPoolable(boolean pool)
 260     {
 261         return;
 262     }
 263     public boolean isWrapperFor(Class ifact) throws SQLException
 264     {
 265         throw getException(CSQL_NOT_SUPPORTED);
 266     }
 267     public Class unwrap(Class iface) throws SQLException
 268     {
 269         throw getException(CSQL_NOT_SUPPORTED);
 270     }
 271     public boolean isClosed()
 272     {
 273         return closedFlag;
 274     }
 275
 276 }