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 }