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 verifyAutoGeneratedKeysParameter(autoGeneratedKeys);
189 MockPreparedStatement statement = new MockPreparedStatement(this, sql, autoGeneratedKeys == Statement.RETURN_GENERATED_KEYS);;
190 getPreparedStatementResultSetHandler().addPreparedStatement(statement);
191 return statement;
192 }
193
194 public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
195 {
196 return prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
197 }
198
199 public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
200 {
201 return prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
202 }
203
204 private void verifyAutoGeneratedKeysParameter(int autoGeneratedKeys) throws SQLException
205 {
206 if(Statement.RETURN_GENERATED_KEYS != autoGeneratedKeys && Statement.NO_GENERATED_KEYS != autoGeneratedKeys)
207 {
208 throw new SQLException("autoGeneratedKeys must be either Statement.RETURN_GENERATED_KEYS or Statement.NO_GENERATED_KEYS");
209 }
210 }
211
212 public void close() throws SQLException
213 {
214 closed = true;
215 }
216
217 public boolean getAutoCommit() throws SQLException
218 {
219 return autoCommit;
220 }
221
222 public String getCatalog() throws SQLException
223 {
224 return catalog;
225 }
226
227 public int getHoldability() throws SQLException
228 {
229 return holdability;
230 }
231
232 public DatabaseMetaData getMetaData() throws SQLException
233 {
234 return metaData;
235 }
236
237 public int getTransactionIsolation() throws SQLException
238 {
239 return level;
240 }
241
242 public Map getTypeMap() throws SQLException
243 {
244 return typeMap;
245 }
246
247 public SQLWarning getWarnings() throws SQLException
248 {
249 return null;
250 }
251
252 public boolean isClosed() throws SQLException
253 {
254 return closed;
255 }
256
257 public boolean isReadOnly() throws SQLException
258 {
259 return readOnly;
260 }
261
262 public String nativeSQL(String sql) throws SQLException
263 {
264 return sql;
265 }
266
267 public void setAutoCommit(boolean autoCommit) throws SQLException
268 {
269 this.autoCommit = autoCommit;
270 }
271
272 public void setCatalog(String catalog) throws SQLException
273 {
274 this.catalog = catalog;
275 }
276
277 public void setHoldability(int holdability) throws SQLException
278 {
279 this.holdability = holdability;
280 }
281
282 public void setReadOnly(boolean readOnly) throws SQLException
283 {
284 this.readOnly = readOnly;
285 }
286
287 public Savepoint setSavepoint() throws SQLException
288 {
289 return setSavepoint("");
290 }
291
292 public Savepoint setSavepoint(String name) throws SQLException
293 {
294 MockSavepoint savePoint = new MockSavepoint(name, savepointCount);
295 savepoints.put(new Integer(savePoint.getSavepointId()), savePoint);
296 savepointCount++;
297 return savePoint;
298 }
299
300 public void setTransactionIsolation(int level) throws SQLException
301 {
302 this.level = level;
303 }
304
305 public void setTypeMap(Map typeMap) throws SQLException
306 {
307 this.typeMap = typeMap;
308 }
309
310 public void releaseSavepoint(Savepoint savepoint) throws SQLException
311 {
312 MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId()));
313 if(currentSavepoint.isReleased())
314 {
315 throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name "
316 + currentSavepoint.getSavepointName() + " is released");
317 }
318 currentSavepoint.setReleased(true);
319 }
320
321 public void commit() throws SQLException
322 {
323 numberCommits++;
324 }
325
326 public void rollback() throws SQLException
327 {
328 numberRollbacks++;
329 }
330
331 public void rollback(Savepoint savepoint) throws SQLException
332 {
333 MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(new Integer(savepoint.getSavepointId()));
334 if(currentSavepoint.isReleased())
335 {
336 throw new SQLException("Savepoint with id " + currentSavepoint.getSavepointId() + " and name " + currentSavepoint.getSavepointName() + " is released");
337 }
338 currentSavepoint.setRolledBack(true);
339 numberRollbacks++;
340 }
341
342 public void clearWarnings() throws SQLException
343 {
344
345 }
346 }