001 package com.mockrunner.mock.jdbc; 002 003 import java.sql.CallableStatement; 004 import java.sql.Connection; 005 import java.sql.DatabaseMetaData; 006 import java.sql.PreparedStatement; 007 import java.sql.ResultSet; 008 import java.sql.SQLException; 009 import java.sql.SQLWarning; 010 import java.sql.Savepoint; 011 import java.sql.Statement; 012 import java.util.Collections; 013 import java.util.HashMap; 014 import java.util.Map; 015 016 import com.mockrunner.base.NestedApplicationException; 017 import com.mockrunner.jdbc.CallableStatementResultSetHandler; 018 import com.mockrunner.jdbc.PreparedStatementResultSetHandler; 019 import com.mockrunner.jdbc.StatementResultSetHandler; 020 021 /** 022 * Mock implementation of <code>Connection</code>. 023 */ 024 public class MockConnection implements Connection 025 { 026 private StatementResultSetHandler statementHandler; 027 private PreparedStatementResultSetHandler preparedStatementHandler; 028 private CallableStatementResultSetHandler callableStatementHandler; 029 private DatabaseMetaData metaData; 030 private Map savepoints; 031 private int savepointCount; 032 private boolean closed; 033 private boolean autoCommit; 034 private boolean readOnly; 035 private int holdability; 036 private int level; 037 private Map typeMap; 038 private String catalog ; 039 private int numberCommits; 040 private int numberRollbacks; 041 042 public MockConnection() 043 { 044 statementHandler = new StatementResultSetHandler(); 045 preparedStatementHandler = new PreparedStatementResultSetHandler(); 046 callableStatementHandler = new CallableStatementResultSetHandler(); 047 metaData = new MockDatabaseMetaData(); 048 ((MockDatabaseMetaData)metaData).setConnection(this); 049 closed = false; 050 autoCommit = false; 051 readOnly = false; 052 holdability = ResultSet.HOLD_CURSORS_OVER_COMMIT; 053 try 054 { 055 level = metaData.getDefaultTransactionIsolation(); 056 } 057 catch(SQLException exc) 058 { 059 throw new NestedApplicationException(exc); 060 } 061 typeMap = new HashMap(); 062 savepoints = new HashMap(); 063 savepointCount = 0; 064 catalog = null; 065 numberCommits = 0; 066 numberRollbacks = 0; 067 } 068 069 public void setMetaData(DatabaseMetaData metaData) throws SQLException 070 { 071 if(metaData != null && metaData instanceof MockDatabaseMetaData) 072 { 073 ((MockDatabaseMetaData)metaData).setConnection(this); 074 } 075 this.metaData = metaData; 076 } 077 078 public int getNumberCommits() 079 { 080 return numberCommits; 081 } 082 083 public int getNumberRollbacks() 084 { 085 return numberRollbacks; 086 } 087 088 public Map getSavepointMap() 089 { 090 return Collections.unmodifiableMap(savepoints); 091 } 092 093 public void resetNumberCommits() 094 { 095 numberCommits = 0; 096 } 097 098 public void resetNumberRollbacks() 099 { 100 numberRollbacks = 0; 101 } 102 103 public void resetSavepointMap() 104 { 105 savepoints.clear(); 106 } 107 108 public StatementResultSetHandler getStatementResultSetHandler() 109 { 110 return statementHandler; 111 } 112 113 public PreparedStatementResultSetHandler getPreparedStatementResultSetHandler() 114 { 115 return preparedStatementHandler; 116 } 117 118 public CallableStatementResultSetHandler getCallableStatementResultSetHandler() 119 { 120 return callableStatementHandler; 121 } 122 123 public Statement createStatement() throws SQLException 124 { 125 MockStatement statement = new MockStatement(this); 126 getStatementResultSetHandler().addStatement(statement); 127 return statement; 128 } 129 130 public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException 131 { 132 MockStatement statement = new MockStatement(this, resultSetType, resultSetConcurrency); 133 getStatementResultSetHandler().addStatement(statement); 134 return statement; 135 } 136 137 public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException 138 { 139 MockStatement statement = new MockStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability); 140 getStatementResultSetHandler().addStatement(statement); 141 return statement; 142 } 143 144 public CallableStatement prepareCall(String sql) throws SQLException 145 { 146 MockCallableStatement statement = new MockCallableStatement(this, sql); 147 getCallableStatementResultSetHandler().addCallableStatement(statement); 148 return statement; 149 } 150 151 public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException 152 { 153 MockCallableStatement statement = new MockCallableStatement(this, sql, resultSetType, resultSetConcurrency); 154 getCallableStatementResultSetHandler().addCallableStatement(statement); 155 return statement; 156 } 157 158 public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException 159 { 160 MockCallableStatement statement = new MockCallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability); 161 getCallableStatementResultSetHandler().addCallableStatement(statement); 162 return statement; 163 } 164 165 public PreparedStatement prepareStatement(String sql) throws SQLException 166 { 167 MockPreparedStatement statement = new MockPreparedStatement(this, sql); 168 getPreparedStatementResultSetHandler().addPreparedStatement(statement); 169 return statement; 170 } 171 172 public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException 173 { 174 MockPreparedStatement statement = new MockPreparedStatement(this, sql, resultSetType, resultSetConcurrency); 175 getPreparedStatementResultSetHandler().addPreparedStatement(statement); 176 return statement; 177 } 178 179 public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException 180 { 181 MockPreparedStatement statement = new MockPreparedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability); 182 getPreparedStatementResultSetHandler().addPreparedStatement(statement); 183 return statement; 184 } 185 186 public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException 187 { 188 return prepareStatement(sql); 189 } 190 191 public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException 192 { 193 return prepareStatement(sql); 194 } 195 196 public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException 197 { 198 return prepareStatement(sql); 199 } 200 201 public void close() throws SQLException 202 { 203 closed = true; 204 } 205 206 public boolean getAutoCommit() throws SQLException 207 { 208 return autoCommit; 209 } 210 211 public String getCatalog() throws SQLException 212 { 213 return catalog; 214 } 215 216 public int getHoldability() throws SQLException 217 { 218 return holdability; 219 } 220 221 public DatabaseMetaData getMetaData() throws SQLException 222 { 223 return metaData; 224 } 225 226 public int getTransactionIsolation() throws SQLException 227 { 228 return level; 229 } 230 231 public Map getTypeMap() throws SQLException 232 { 233 return typeMap; 234 } 235 236 public SQLWarning getWarnings() throws SQLException 237 { 238 return null; 239 } 240 241 public boolean isClosed() throws SQLException 242 { 243 return closed; 244 } 245 246 public boolean isReadOnly() throws SQLException 247 { 248 return readOnly; 249 } 250 251 public String nativeSQL(String sql) throws SQLException 252 { 253 return sql; 254 } 255 256 public void setAutoCommit(boolean autoCommit) throws SQLException 257 { 258 this.autoCommit = autoCommit; 259 } 260 261 public void setCatalog(String catalog) throws SQLException 262 { 263 this.catalog = catalog; 264 } 265 266 public void setHoldability(int holdability) throws SQLException 267 { 268 this.holdability = holdability; 269 } 270 271 public void setReadOnly(boolean readOnly) throws SQLException 272 { 273 this.readOnly = readOnly; 274 } 275 276 public Savepoint setSavepoint() throws SQLException 277 { 278 return setSavepoint(""); 279 } 280 281 public Savepoint setSavepoint(String name) throws SQLException 282 { 283 MockSavepoint savePoint = new MockSavepoint(name, savepointCount); 284 savepoints.put(new Integer(savePoint.getSavepointId()), savePoint); 285 savepointCount++; 286 return savePoint; 287 } 288 289 public void setTransactionIsolation(int level) throws SQLException 290 { 291 this.level = level; 292 } 293 294 public void setTypeMap(Map typeMap) throws SQLException 295 { 296 this.typeMap = typeMap; 297 } 298 299 public void releaseSavepoint(Savepoint savepoint) throws SQLException 300 { 301 MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId())); 302 if(currentSavepoint.isReleased()) 303 { 304 throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " 305 + currentSavepoint.getSavepointName() + " is released"); 306 } 307 currentSavepoint.setReleased(true); 308 } 309 310 public void commit() throws SQLException 311 { 312 numberCommits++; 313 } 314 315 public void rollback() throws SQLException 316 { 317 numberRollbacks++; 318 } 319 320 public void rollback(Savepoint savepoint) throws SQLException 321 { 322 MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId())); 323 if(currentSavepoint.isReleased()) 324 { 325 throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " 326 + currentSavepoint.getSavepointName() + " is released"); 327 } 328 currentSavepoint.setRolledBack(true); 329 numberRollbacks++; 330 } 331 332 public void clearWarnings() throws SQLException 333 { 334 335 } 336 }