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