001package org.javasimon.jdbc4;
002
003import java.io.InputStream;
004import java.io.Reader;
005import java.math.BigDecimal;
006import java.net.URL;
007import java.sql.Array;
008import java.sql.Blob;
009import java.sql.Clob;
010import java.sql.Connection;
011import java.sql.Date;
012import java.sql.NClob;
013import java.sql.ParameterMetaData;
014import java.sql.PreparedStatement;
015import java.sql.Ref;
016import java.sql.ResultSet;
017import java.sql.ResultSetMetaData;
018import java.sql.RowId;
019import java.sql.SQLException;
020import java.sql.SQLXML;
021import java.sql.Time;
022import java.sql.Timestamp;
023import java.util.Calendar;
024
025import org.javasimon.Split;
026
027/**
028 * Simon JDBC proxy prepared statement implementation class.
029 *
030 * @author Radovan Sninsky
031 * @author <a href="mailto:virgo47@gmail.com">Richard "Virgo" Richter</a>
032 * @see java.sql.PreparedStatement
033 * @since 2.4
034 */
035@SuppressWarnings("deprecation")
036public class SimonPreparedStatement extends SimonStatement implements PreparedStatement {
037        /**
038         * SQL string.
039         */
040        protected String sql;
041
042        private PreparedStatement stmt;
043
044        /**
045         * Class constructor, initializes Simons (lifespan, active) related to statement.
046         *
047         * @param conn database connection (simon impl.)
048         * @param stmt real prepared statement
049         * @param sql sql command
050         * @param prefix hierarchy prefix for statement Simons
051         */
052        SimonPreparedStatement(Connection conn, PreparedStatement stmt, String sql, String prefix) {
053                super(conn, stmt, prefix);
054
055                this.stmt = stmt;
056                this.sql = sql;
057        }
058
059        /**
060         * Called before each prepared SQL command execution. Prepares (obtains and starts)
061         * {@link org.javasimon.Stopwatch Stopwatch Simon} for measure SQL operation.
062         *
063         * @return Simon stopwatch object or null if sql is null or empty
064         */
065        private Split prepare() {
066                if (sql != null && !sql.equals("")) {
067                        sqlNormalizer = new SqlNormalizer(sql);
068                        sqlCmdLabel = prefix + ".sql." + sqlNormalizer.getType();
069                        return startSplit();
070                } else {
071                        return null;
072                }
073        }
074
075        /**
076         * Measure and execute prepared SQL operation.
077         *
078         * @return database rows and columns
079         * @throws java.sql.SQLException if real calls fails
080         */
081        @Override
082        public final ResultSet executeQuery() throws SQLException {
083                Split split = prepare();
084                try {
085                        return new SimonResultSet(stmt.executeQuery(), this, prefix, split.getStopwatch().getName());
086                } finally {
087                        finish(split);
088                }
089        }
090
091        /**
092         * Measure and execute prepared SQL operation.
093         *
094         * @return count of updated rows
095         * @throws java.sql.SQLException if real calls fails
096         */
097        @Override
098        public final int executeUpdate() throws SQLException {
099                Split split = prepare();
100                try {
101                        return stmt.executeUpdate();
102                } finally {
103                        finish(split);
104                }
105        }
106
107        /**
108         * Measure and execute prepared SQL operation.
109         *
110         * @return <code>true</code> if the first result is a <code>ResultSet</code> object;
111         *         <code>false</code> if it is an update count or there are no results
112         * @throws java.sql.SQLException if real calls fails
113         */
114        @Override
115        public final boolean execute() throws SQLException {
116                Split split = prepare();
117                try {
118                        return stmt.execute();
119                } finally {
120                        finish(split);
121                }
122        }
123
124        /**
125         * Adds prepared SQL command into batch list of sql and also into real batch.
126         *
127         * @throws java.sql.SQLException if real calls fails
128         */
129        @Override
130        public final void addBatch() throws SQLException {
131                batchSql.add(sql);
132
133                stmt.addBatch();
134        }
135
136        //// NOT MONITORED
137
138        @Override
139        public final void setNull(int i, int i1) throws SQLException {
140                stmt.setNull(i, i1);
141        }
142
143        @Override
144        public final void setBoolean(int i, boolean b) throws SQLException {
145                stmt.setBoolean(i, b);
146        }
147
148        @Override
149        public final void setByte(int i, byte b) throws SQLException {
150                stmt.setByte(i, b);
151        }
152
153        @Override
154        public final void setShort(int i, short i1) throws SQLException {
155                stmt.setShort(i, i1);
156        }
157
158        @Override
159        public final void setInt(int i, int i1) throws SQLException {
160                stmt.setInt(i, i1);
161        }
162
163        @Override
164        public final void setLong(int i, long l) throws SQLException {
165                stmt.setLong(i, l);
166        }
167
168        @Override
169        public final void setFloat(int i, float v) throws SQLException {
170                stmt.setFloat(i, v);
171        }
172
173        @Override
174        public final void setDouble(int i, double v) throws SQLException {
175                stmt.setDouble(i, v);
176        }
177
178        @Override
179        public final void setBigDecimal(int i, BigDecimal bigDecimal) throws SQLException {
180                stmt.setBigDecimal(i, bigDecimal);
181        }
182
183        @Override
184        public final void setString(int i, String s) throws SQLException {
185                stmt.setString(i, s);
186        }
187
188        @Override
189        public final void setBytes(int i, byte[] bytes) throws SQLException {
190                stmt.setBytes(i, bytes);
191        }
192
193        @Override
194        public final void setDate(int i, Date date) throws SQLException {
195                stmt.setDate(i, date);
196        }
197
198        @Override
199        public final void setTime(int i, Time time) throws SQLException {
200                stmt.setTime(i, time);
201        }
202
203        @Override
204        public final void setTimestamp(int i, Timestamp timestamp) throws SQLException {
205                stmt.setTimestamp(i, timestamp);
206        }
207
208        @Override
209        public final void setAsciiStream(int i, InputStream inputStream, int i1) throws SQLException {
210                stmt.setAsciiStream(i, inputStream, i1);
211        }
212
213        @Deprecated
214        @Override
215        public final void setUnicodeStream(int i, InputStream inputStream, int i1) throws SQLException {
216                stmt.setUnicodeStream(i, inputStream, i1);
217        }
218
219        @Override
220        public final void setBinaryStream(int i, InputStream inputStream, int i1) throws SQLException {
221                stmt.setBinaryStream(i, inputStream, i1);
222        }
223
224        @Override
225        public final void clearParameters() throws SQLException {
226                stmt.clearParameters();
227        }
228
229        @Override
230        public final void setObject(int i, Object o, int i1) throws SQLException {
231                stmt.setObject(i, o, i1);
232        }
233
234        @Override
235        public final void setObject(int i, Object o) throws SQLException {
236                stmt.setObject(i, o);
237        }
238
239        @Override
240        public final void setObject(int i, Object o, int i1, int i2) throws SQLException {
241                stmt.setObject(i, o, i1, i2);
242        }
243
244        @Override
245        public final void setCharacterStream(int i, Reader reader, int i1) throws SQLException {
246                stmt.setCharacterStream(i, reader, i1);
247        }
248
249        @Override
250        public final void setRef(int i, Ref ref) throws SQLException {
251                stmt.setRef(i, ref);
252        }
253
254        @Override
255        public final void setBlob(int i, Blob blob) throws SQLException {
256                stmt.setBlob(i, blob);
257        }
258
259        @Override
260        public final void setClob(int i, Clob clob) throws SQLException {
261                stmt.setClob(i, clob);
262        }
263
264        @Override
265        public final void setArray(int i, Array array) throws SQLException {
266                stmt.setArray(i, array);
267        }
268
269        @Override
270        public final ResultSetMetaData getMetaData() throws SQLException {
271                return stmt.getMetaData();
272        }
273
274        public final void setDate(int i, Date date, Calendar calendar) throws SQLException {
275                stmt.setDate(i, date, calendar);
276        }
277
278        @Override
279        public final void setTime(int i, Time time, Calendar calendar) throws SQLException {
280                stmt.setTime(i, time, calendar);
281        }
282
283        @Override
284        public final void setTimestamp(int i, Timestamp timestamp, Calendar calendar) throws SQLException {
285                stmt.setTimestamp(i, timestamp, calendar);
286        }
287
288        @Override
289        public final void setNull(int i, int i1, String s) throws SQLException {
290                stmt.setNull(i, i1, s);
291        }
292
293        @Override
294        public final void setURL(int i, URL url) throws SQLException {
295                stmt.setURL(i, url);
296        }
297
298        @Override
299        public final ParameterMetaData getParameterMetaData() throws SQLException {
300                return stmt.getParameterMetaData();
301        }
302
303        @Override
304        public final void setRowId(int i, RowId rowId) throws SQLException {
305                stmt.setRowId(i, rowId);
306        }
307
308        @Override
309        public final void setNString(int i, String s) throws SQLException {
310                stmt.setNString(i, s);
311        }
312
313        @Override
314        public final void setNCharacterStream(int i, Reader reader, long l) throws SQLException {
315                stmt.setNCharacterStream(i, reader, l);
316        }
317
318        @Override
319        public final void setNClob(int i, NClob nClob) throws SQLException {
320                stmt.setNClob(i, nClob);
321        }
322
323        @Override
324        public final void setClob(int i, Reader reader, long l) throws SQLException {
325                stmt.setClob(i, reader, l);
326        }
327
328        @Override
329        public final void setBlob(int i, InputStream inputStream, long l) throws SQLException {
330                stmt.setBlob(i, inputStream, l);
331        }
332
333        @Override
334        public final void setNClob(int i, Reader reader, long l) throws SQLException {
335                stmt.setNClob(i, reader, l);
336        }
337
338        @Override
339        public final void setSQLXML(int i, SQLXML sqlxml) throws SQLException {
340                stmt.setSQLXML(i, sqlxml);
341        }
342
343        @Override
344        public final void setAsciiStream(int i, InputStream inputStream, long l) throws SQLException {
345                stmt.setAsciiStream(i, inputStream, l);
346        }
347
348        @Override
349        public final void setBinaryStream(int i, InputStream inputStream, long l) throws SQLException {
350                stmt.setBinaryStream(i, inputStream);
351        }
352
353        @Override
354        public final void setCharacterStream(int i, Reader reader, long l) throws SQLException {
355                stmt.setCharacterStream(i, reader, l);
356        }
357
358        @Override
359        public final void setAsciiStream(int i, InputStream inputStream) throws SQLException {
360                stmt.setAsciiStream(i, inputStream);
361        }
362
363        @Override
364        public final void setBinaryStream(int i, InputStream inputStream) throws SQLException {
365                stmt.setBinaryStream(i, inputStream);
366        }
367
368        @Override
369        public final void setCharacterStream(int i, Reader reader) throws SQLException {
370                stmt.setCharacterStream(i, reader);
371        }
372
373        @Override
374        public final void setNCharacterStream(int i, Reader reader) throws SQLException {
375                stmt.setNCharacterStream(i, reader);
376        }
377
378        @Override
379        public final void setClob(int i, Reader reader) throws SQLException {
380                stmt.setClob(i, reader);
381        }
382
383        @Override
384        public final void setBlob(int i, InputStream inputStream) throws SQLException {
385                stmt.setBlob(i, inputStream);
386        }
387
388        @Override
389        public final void setNClob(int i, Reader reader) throws SQLException {
390                stmt.setNClob(i, reader);
391        }
392
393}