可输出sql的PrepareStatement封装

   1 import java.io.InputStream;
   2 import java.io.Reader;
   3 import java.net.URL;
   4 import java.sql.Connection;
   5 import java.sql.NClob;
   6 import java.sql.ParameterMetaData;
   7 import java.sql.PreparedStatement;
   8 import java.sql.ResultSet;
   9 import java.sql.RowId;
  10 import java.sql.SQLException;
  11 import java.sql.SQLXML;
  12 import java.util.ArrayList;
  13 import java.util.Date;
  14 import java.util.StringTokenizer;
  15 
  16 /**
  17  * A <code>LoggableStatement<code> is a {@link java.sql.PreparedStatement PreparedStatement} with added logging capability.
  18  * <p>
  19  * In addition to the methods declared in <code>PreparedStatement</code>,
  20  * <code>LoggableStatement<code> provides a method {@link #getQueryString} which can be used to get the query string in a format
  21  * suitable for logging.
  22  *
  23  * @author Jens Wyke (jens.wyke@se.ibm.com)
  24  *
  25  */
  26 public class LoggableStatement implements PreparedStatement {
  27 
  28     /**
  29      * used for storing parameter values needed for producing log
  30      */
  31     private ArrayList parameterValues;
  32 
  33     /**
  34      *the query string with question marks as parameter placeholders
  35      */
  36     private String sqlTemplate;
  37 
  38     /**
  39      *  a statement created from a real database connection
  40      */
  41     private PreparedStatement wrappedStatement;
  42 
  43     /**
  44         * Constructs a LoggableStatement.
  45         *
  46         * Creates {@link java.sql.PreparedStatement PreparedStatement} with the query string <code>sql</code> using
  47         * the specified <code>connection</code> by calling {@link java.sql.Connection#prepareStatement(String)}.
  48         * <p>
  49         * Whenever a call is made to this <code>LoggableStatement</code> it is forwarded to the prepared statment created from
  50         * <code>connection</code> after first saving relevant parameters for use in logging output.
  51         *
  52         * @param Connection java.sql.Connection a JDBC-connection to be used for obtaining a "real statement"
  53         * @param sql java.lang.String thw sql to exectute
  54         * @exception java.sql.SQLException if a <code>PreparedStatement</code> cannot be created
  55         * using the supplied <code>connection</code> and <code>sql</code>
  56         */
  57 
  58     public LoggableStatement(Connection connection, String sql)
  59         throws SQLException {
  60         wrappedStatement = connection.prepareStatement(sql);
  61         sqlTemplate = sql;
  62         parameterValues = new ArrayList();
  63     }
  64 
  65     /**
  66      * JDBC 2.0
  67      *
  68      * Adds a set of parameters to the batch.
  69      *
  70      * @exception SQLException if a database access error occurs
  71      * @see Statement#addBatch
  72      */
  73     public void addBatch() throws java.sql.SQLException {
  74         wrappedStatement.addBatch();
  75     }
  76     /**
  77      * JDBC 2.0
  78      *
  79      * Adds a SQL command to the current batch of commmands for the statement.
  80      * This method is optional.
  81      *
  82      * @param sql typically this is a static SQL INSERT or UPDATE statement
  83      * @exception SQLException if a database access error occurs, or the
  84      * driver does not support batch statements
  85      */
  86     public void addBatch(String sql) throws java.sql.SQLException {
  87         wrappedStatement.addBatch(sql);
  88     }
  89     /**
  90      * Cancels this <code>Statement</code> object if both the DBMS and
  91      * driver support aborting an SQL statement.
  92      * This method can be used by one thread to cancel a statement that
  93      * is being executed by another thread.
  94      *
  95      * @exception SQLException if a database access error occurs
  96      */
  97     public void cancel() throws SQLException {
  98         wrappedStatement.cancel();
  99     }
 100     /**
 101      * JDBC 2.0
 102      *
 103      * Makes the set of commands in the current batch empty.
 104      * This method is optional.
 105      *
 106      * @exception SQLException if a database access error occurs or the
 107      * driver does not support batch statements
 108      */
 109     public void clearBatch() throws java.sql.SQLException {
 110         wrappedStatement.clearBatch();
 111     }
 112     /**
 113      * Clears the current parameter values immediately.
 114      * <P>In general, parameter values remain in force for repeated use of a
 115      * Statement. Setting a parameter value automatically clears its
 116      * previous value.  However, in some cases it is useful to immediately
 117      * release the resources used by the current parameter values; this can
 118      * be done by calling clearParameters.
 119      *
 120      * @exception SQLException if a database access error occurs
 121      */
 122     public void clearParameters() throws java.sql.SQLException {
 123         wrappedStatement.clearParameters();
 124     }
 125     /**
 126      * Clears all the warnings reported on this <code>Statement</code>
 127      * object. After a call to this method,
 128      * the method <code>getWarnings</code> will return
 129      * null until a new warning is reported for this Statement.
 130      *
 131      * @exception SQLException if a database access error occurs
 132      */
 133     public void clearWarnings() throws java.sql.SQLException {
 134         wrappedStatement.clearWarnings();
 135     }
 136     /**
 137      * Releases this <code>Statement</code> object's database
 138      * and JDBC resources immediately instead of waiting for
 139      * this to happen when it is automatically closed.
 140      * It is generally good practice to release resources as soon as
 141      * you are finished with them to avoid tying up database
 142      * resources.
 143      * <P><B>Note:</B> A Statement is automatically closed when it is
 144      * garbage collected. When a Statement is closed, its current
 145      * ResultSet, if one exists, is also closed.
 146      *
 147      * @exception SQLException if a database access error occurs
 148      */
 149     public void close() throws java.sql.SQLException {
 150         wrappedStatement.close();
 151     }
 152     /**
 153      * Executes any kind of SQL statement.
 154      * Some prepared statements return multiple results; the execute
 155      * method handles these complex statements as well as the simpler
 156      * form of statements handled by executeQuery and executeUpdate.
 157      *
 158      * @exception SQLException if a database access error occurs
 159      * @see Statement#execute
 160      */
 161     public boolean execute() throws java.sql.SQLException {
 162         return wrappedStatement.execute();
 163     }
 164     /**
 165      * Executes a SQL statement that may return multiple results.
 166      * Under some (uncommon) situations a single SQL statement may return
 167      * multiple result sets and/or update counts.  Normally you can ignore
 168      * this unless you are (1) executing a stored procedure that you know may
 169      * return multiple results or (2) you are dynamically executing an
 170      * unknown SQL string.  The  methods <code>execute</code>,
 171      * <code>getMoreResults</code>, <code>getResultSet</code>,
 172      * and <code>getUpdateCount</code> let you navigate through multiple results.
 173      *
 174      * The <code>execute</code> method executes a SQL statement and indicates the
 175      * form of the first result.  You can then use getResultSet or
 176      * getUpdateCount to retrieve the result, and getMoreResults to
 177      * move to any subsequent result(s).
 178      *
 179      * @param sql any SQL statement
 180      * @return true if the next result is a ResultSet; false if it is
 181      * an update count or there are no more results
 182      * @exception SQLException if a database access error occurs
 183      * @see #getResultSet
 184      * @see #getUpdateCount
 185      * @see #getMoreResults
 186      */
 187     public boolean execute(String sql) throws java.sql.SQLException {
 188         return wrappedStatement.execute(sql);
 189     }
 190     /**
 191      * JDBC 2.0
 192      *
 193      * Submits a batch of commands to the database for execution.
 194      * This method is optional.
 195      *
 196      * @return an array of update counts containing one element for each
 197      * command in the batch.  The array is ordered according
 198      * to the order in which commands were inserted into the batch.
 199      * @exception SQLException if a database access error occurs or the
 200      * driver does not support batch statements
 201      */
 202     public int[] executeBatch() throws java.sql.SQLException {
 203         return wrappedStatement.executeBatch();
 204     }
 205     /**
 206      * Executes the SQL query in this <code>PreparedStatement</code> object
 207      * and returns the result set generated by the query.
 208      *
 209      * @return a ResultSet that contains the data produced by the
 210      * query; never null
 211      * @exception SQLException if a database access error occurs
 212      */
 213     public java.sql.ResultSet executeQuery() throws java.sql.SQLException {
 214         return wrappedStatement.executeQuery();
 215     }
 216     /**
 217      * Executes a SQL statement that returns a single ResultSet.
 218      *
 219      * @param sql typically this is a static SQL SELECT statement
 220      * @return a ResultSet that contains the data produced by the
 221      * query; never null
 222      * @exception SQLException if a database access error occurs
 223      */
 224     public java.sql.ResultSet executeQuery(String sql)
 225         throws java.sql.SQLException {
 226         return wrappedStatement.executeQuery(sql);
 227     }
 228     /**
 229      * Executes the SQL INSERT, UPDATE or DELETE statement
 230      * in this <code>PreparedStatement</code> object.
 231      * In addition,
 232      * SQL statements that return nothing, such as SQL DDL statements,
 233      * can be executed.
 234      *
 235      * @return either the row count for INSERT, UPDATE or DELETE statements;
 236      * or 0 for SQL statements that return nothing
 237      * @exception SQLException if a database access error occurs
 238      */
 239     public int executeUpdate() throws java.sql.SQLException {
 240         return wrappedStatement.executeUpdate();
 241     }
 242     /**
 243      * Executes an SQL INSERT, UPDATE or DELETE statement. In addition,
 244      * SQL statements that return nothing, such as SQL DDL statements,
 245      * can be executed.
 246      *
 247      * @param sql a SQL INSERT, UPDATE or DELETE statement or a SQL
 248      * statement that returns nothing
 249      * @return either the row count for INSERT, UPDATE or DELETE or 0
 250      * for SQL statements that return nothing
 251      * @exception SQLException if a database access error occurs
 252      */
 253     public int executeUpdate(String sql) throws java.sql.SQLException {
 254         return wrappedStatement.executeUpdate(sql);
 255     }
 256     /**
 257      * JDBC 2.0
 258      *
 259      * Returns the <code>Connection</code> object
 260      * that produced this <code>Statement</code> object.
 261      * @return the connection that produced this statement
 262      * @exception SQLException if a database access error occurs
 263      */
 264     public java.sql.Connection getConnection() throws java.sql.SQLException {
 265         return wrappedStatement.getConnection();
 266     }
 267     /**
 268      * JDBC 2.0
 269      *
 270      * Retrieves the direction for fetching rows from
 271      * database tables that is the default for result sets
 272      * generated from this <code>Statement</code> object.
 273      * If this <code>Statement</code> object has not set
 274      * a fetch direction by calling the method <code>setFetchDirection</code>,
 275      * the return value is implementation-specific.
 276      *
 277      * @return the default fetch direction for result sets generated
 278      *          from this <code>Statement</code> object
 279      * @exception SQLException if a database access error occurs
 280      */
 281     public int getFetchDirection() throws java.sql.SQLException {
 282         return wrappedStatement.getFetchDirection();
 283     }
 284     /**
 285      * JDBC 2.0
 286      *
 287      * Retrieves the number of result set rows that is the default
 288      * fetch size for result sets
 289      * generated from this <code>Statement</code> object.
 290      * If this <code>Statement</code> object has not set
 291      * a fetch size by calling the method <code>setFetchSize</code>,
 292      * the return value is implementation-specific.
 293      * @return the default fetch size for result sets generated
 294      *          from this <code>Statement</code> object
 295      * @exception SQLException if a database access error occurs
 296      */
 297     public int getFetchSize() throws java.sql.SQLException {
 298         return wrappedStatement.getFetchSize();
 299     }
 300     /**
 301      * Returns the maximum number of bytes allowed
 302      * for any column value.
 303      * This limit is the maximum number of bytes that can be
 304      * returned for any column value.
 305      * The limit applies only to BINARY,
 306      * VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR
 307      * columns.  If the limit is exceeded, the excess data is silently
 308      * discarded.
 309      *
 310      * @return the current max column size limit; zero means unlimited
 311      * @exception SQLException if a database access error occurs
 312      */
 313     public int getMaxFieldSize() throws java.sql.SQLException {
 314         return wrappedStatement.getMaxFieldSize();
 315     }
 316     /**
 317      * Retrieves the maximum number of rows that a
 318      * ResultSet can contain.  If the limit is exceeded, the excess
 319      * rows are silently dropped.
 320      *
 321      * @return the current max row limit; zero means unlimited
 322      * @exception SQLException if a database access error occurs
 323      */
 324     public int getMaxRows() throws java.sql.SQLException {
 325         return wrappedStatement.getMaxRows();
 326     }
 327     /**
 328      * JDBC 2.0
 329      *
 330      * Gets the number, types and properties of a ResultSet's columns.
 331      *
 332      * @return the description of a ResultSet's columns
 333      * @exception SQLException if a database access error occurs
 334      */
 335     public java.sql.ResultSetMetaData getMetaData()
 336         throws java.sql.SQLException {
 337         return wrappedStatement.getMetaData();
 338     }
 339     /**
 340      * Moves to a Statement's next result.  It returns true if
 341      * this result is a ResultSet.  This method also implicitly
 342      * closes any current ResultSet obtained with getResultSet.
 343      *
 344      * There are no more results when (!getMoreResults() &&
 345      * (getUpdateCount() == -1)
 346      *
 347      * @return true if the next result is a ResultSet; false if it is
 348      * an update count or there are no more results
 349      * @exception SQLException if a database access error occurs
 350      * @see #execute
 351      */
 352     public boolean getMoreResults() throws java.sql.SQLException {
 353         return wrappedStatement.getMoreResults();
 354     }
 355     /**
 356      * Retrieves the number of seconds the driver will
 357      * wait for a Statement to execute. If the limit is exceeded, a
 358      * SQLException is thrown.
 359      *
 360      * @return the current query timeout limit in seconds; zero means unlimited
 361      * @exception SQLException if a database access error occurs
 362      */
 363     public int getQueryTimeout() throws java.sql.SQLException {
 364         return wrappedStatement.getQueryTimeout();
 365     }
 366     /**
 367      *  Returns the current result as a <code>ResultSet</code> object.
 368      *  This method should be called only once per result.
 369      *
 370      * @return the current result as a ResultSet; null if the result
 371      * is an update count or there are no more results
 372      * @exception SQLException if a database access error occurs
 373      * @see #execute
 374      */
 375     public java.sql.ResultSet getResultSet() throws java.sql.SQLException {
 376         return wrappedStatement.getResultSet();
 377     }
 378     /**
 379      * JDBC 2.0
 380      *
 381      * Retrieves the result set concurrency.
 382      */
 383     public int getResultSetConcurrency() throws java.sql.SQLException {
 384         return wrappedStatement.getResultSetConcurrency();
 385     }
 386     /**
 387      * JDBC 2.0
 388      *
 389      * Determine the result set type.
 390      */
 391     public int getResultSetType() throws java.sql.SQLException {
 392         return wrappedStatement.getResultSetType();
 393     }
 394     /**
 395      *  Returns the current result as an update count;
 396      *  if the result is a ResultSet or there are no more results, -1
 397      *  is returned.
 398      *  This method should be called only once per result.
 399      *
 400      * @return the current result as an update count; -1 if it is a
 401      * ResultSet or there are no more results
 402      * @exception SQLException if a database access error occurs
 403      * @see #execute
 404      */
 405     public int getUpdateCount() throws java.sql.SQLException {
 406         return wrappedStatement.getUpdateCount();
 407     }
 408     /**
 409      * Retrieves the first warning reported by calls on this Statement.
 410      * Subsequent Statement warnings will be chained to this
 411      * SQLWarning.
 412      *
 413      * <p>The warning chain is automatically cleared each time
 414      * a statement is (re)executed.
 415      *
 416      * <P><B>Note:</B> If you are processing a ResultSet, any
 417      * warnings associated with ResultSet reads will be chained on the
 418      * ResultSet object.
 419      *
 420      * @return the first SQLWarning or null
 421      * @exception SQLException if a database access error occurs
 422      */
 423     public java.sql.SQLWarning getWarnings() throws java.sql.SQLException {
 424         return wrappedStatement.getWarnings();
 425     }
 426     /**
 427      * JDBC 2.0
 428      *
 429      * Sets an Array parameter.
 430      *
 431      * @param i the first parameter is 1, the second is 2, ...
 432      * @param x an object representing an SQL array
 433      * @exception SQLException if a database access error occurs
 434      */
 435     public void setArray(int i, java.sql.Array x)
 436         throws java.sql.SQLException {
 437 
 438         wrappedStatement.setArray(i, x);
 439         saveQueryParamValue(i, x);
 440 
 441     }
 442     /**
 443      * Sets the designated parameter to the given input stream, which will have
 444      * the specified number of bytes.
 445      * When a very large ASCII value is input to a LONGVARCHAR
 446      * parameter, it may be more practical to send it via a
 447      * java.io.InputStream. JDBC will read the data from the stream
 448      * as needed, until it reaches end-of-file.  The JDBC driver will
 449      * do any necessary conversion from ASCII to the database char format.
 450      *
 451      * <P><B>Note:</B> This stream object can either be a standard
 452      * Java stream object or your own subclass that implements the
 453      * standard interface.
 454      *
 455      * @param parameterIndex the first parameter is 1, the second is 2, ...
 456      * @param x the Java input stream that contains the ASCII parameter value
 457      * @param length the number of bytes in the stream
 458      * @exception SQLException if a database access error occurs
 459      */
 460     public void setAsciiStream(
 461         int parameterIndex,
 462         java.io.InputStream x,
 463         int length)
 464         throws java.sql.SQLException {
 465 
 466         wrappedStatement.setAsciiStream(parameterIndex, x, length);
 467         saveQueryParamValue(parameterIndex, x);
 468     }
 469     /**
 470      * Sets the designated parameter to a java.lang.BigDecimal value.
 471      * The driver converts this to an SQL NUMERIC value when
 472      * it sends it to the database.
 473      *
 474      * @param parameterIndex the first parameter is 1, the second is 2, ...
 475      * @param x the parameter value
 476      * @exception SQLException if a database access error occurs
 477      */
 478     public void setBigDecimal(int parameterIndex, java.math.BigDecimal x)
 479         throws java.sql.SQLException {
 480         wrappedStatement.setBigDecimal(parameterIndex, x);
 481         saveQueryParamValue(parameterIndex, x);
 482 
 483     }
 484     /**
 485      * Sets the designated parameter to the given input stream, which will have
 486      * the specified number of bytes.
 487      * When a very large binary value is input to a LONGVARBINARY
 488      * parameter, it may be more practical to send it via a
 489      * java.io.InputStream. JDBC will read the data from the stream
 490      * as needed, until it reaches end-of-file.
 491      *
 492      * <P><B>Note:</B> This stream object can either be a standard
 493      * Java stream object or your own subclass that implements the
 494      * standard interface.
 495      *
 496      * @param parameterIndex the first parameter is 1, the second is 2, ...
 497      * @param x the java input stream which contains the binary parameter value
 498      * @param length the number of bytes in the stream
 499      * @exception SQLException if a database access error occurs
 500      */
 501     public void setBinaryStream(
 502         int parameterIndex,
 503         java.io.InputStream x,
 504         int length)
 505         throws java.sql.SQLException {
 506         wrappedStatement.setBinaryStream(parameterIndex, x, length);
 507         saveQueryParamValue(parameterIndex, x);
 508 
 509     }
 510     /**
 511      * JDBC 2.0
 512      *
 513      * Sets a BLOB parameter.
 514      *
 515      * @param i the first parameter is 1, the second is 2, ...
 516      * @param x an object representing a BLOB
 517      * @exception SQLException if a database access error occurs
 518      */
 519     public void setBlob(int i, java.sql.Blob x) throws java.sql.SQLException {
 520         wrappedStatement.setBlob(i, x);
 521         saveQueryParamValue(i, x);
 522     }
 523     /**
 524      * Sets the designated parameter to a Java boolean value.  The driver converts this
 525      * to an SQL BIT value when it sends it to the database.
 526      *
 527      * @param parameterIndex the first parameter is 1, the second is 2, ...
 528      * @param x the parameter value
 529      * @exception SQLException if a database access error occurs
 530      */
 531     public void setBoolean(int parameterIndex, boolean x)
 532         throws java.sql.SQLException {
 533         wrappedStatement.setBoolean(parameterIndex, x);
 534         saveQueryParamValue(parameterIndex, new Boolean(x));
 535 
 536     }
 537     /**
 538      * Sets the designated parameter to a Java byte value.  The driver converts this
 539      * to an SQL TINYINT value when it sends it to the database.
 540      *
 541      * @param parameterIndex the first parameter is 1, the second is 2, ...
 542      * @param x the parameter value
 543      * @exception SQLException if a database access error occurs
 544      */
 545     public void setByte(int parameterIndex, byte x)
 546         throws java.sql.SQLException {
 547         wrappedStatement.setByte(parameterIndex, x);
 548         saveQueryParamValue(parameterIndex, new Integer(x));
 549     }
 550     /**
 551      * Sets the designated parameter to a Java array of bytes.  The driver converts
 552      * this to an SQL VARBINARY or LONGVARBINARY (depending on the
 553      * argument's size relative to the driver's limits on VARBINARYs)
 554      * when it sends it to the database.
 555      *
 556      * @param parameterIndex the first parameter is 1, the second is 2, ...
 557      * @param x the parameter value
 558      * @exception SQLException if a database access error occurs
 559      */
 560     public void setBytes(int parameterIndex, byte[] x)
 561         throws java.sql.SQLException {
 562         wrappedStatement.setBytes(parameterIndex, x);
 563         saveQueryParamValue(parameterIndex, x);
 564     }
 565     /**
 566      * JDBC 2.0
 567      *
 568      * Sets the designated parameter to the given <code>Reader</code>
 569      * object, which is the given number of characters long.
 570      * When a very large UNICODE value is input to a LONGVARCHAR
 571      * parameter, it may be more practical to send it via a
 572      * java.io.Reader. JDBC will read the data from the stream
 573      * as needed, until it reaches end-of-file.  The JDBC driver will
 574      * do any necessary conversion from UNICODE to the database char format.
 575      *
 576      * <P><B>Note:</B> This stream object can either be a standard
 577      * Java stream object or your own subclass that implements the
 578      * standard interface.
 579      *
 580      * @param parameterIndex the first parameter is 1, the second is 2, ...
 581      * @param x the java reader which contains the UNICODE data
 582      * @param length the number of characters in the stream
 583      * @exception SQLException if a database access error occurs
 584      */
 585     public void setCharacterStream(
 586         int parameterIndex,
 587         java.io.Reader reader,
 588         int length)
 589         throws java.sql.SQLException {
 590         wrappedStatement.setCharacterStream(parameterIndex, reader, length);
 591         saveQueryParamValue(parameterIndex, reader);
 592 
 593     }
 594     /**
 595      * JDBC 2.0
 596      *
 597      * Sets a CLOB parameter.
 598      *
 599      * @param i the first parameter is 1, the second is 2, ...
 600      * @param x an object representing a CLOB
 601      * @exception SQLException if a database access error occurs
 602      */
 603     public void setClob(int i, java.sql.Clob x) throws java.sql.SQLException {
 604         wrappedStatement.setClob(i, x);
 605         saveQueryParamValue(i, x);
 606 
 607     }
 608     /**
 609      * Defines the SQL cursor name that will be used by
 610      * subsequent Statement <code>execute</code> methods. This name can then be
 611      * used in SQL positioned update/delete statements to identify the
 612      * current row in the ResultSet generated by this statement.  If
 613      * the database doesn't support positioned update/delete, this
 614      * method is a noop.  To insure that a cursor has the proper isolation
 615      * level to support updates, the cursor's SELECT statement should be
 616      * of the form 'select for update ...'. If the 'for update' phrase is
 617      * omitted, positioned updates may fail.
 618      *
 619      * <P><B>Note:</B> By definition, positioned update/delete
 620      * execution must be done by a different Statement than the one
 621      * which generated the ResultSet being used for positioning. Also,
 622      * cursor names must be unique within a connection.
 623      *
 624      * @param name the new cursor name, which must be unique within
 625      *             a connection
 626      * @exception SQLException if a database access error occurs
 627      */
 628     public void setCursorName(String name) throws java.sql.SQLException {
 629         wrappedStatement.setCursorName(name);
 630 
 631     }
 632     /**
 633      * Sets the designated parameter to a java.sql.Date value.  The driver converts this
 634      * to an SQL DATE value when it sends it to the database.
 635      *
 636      * @param parameterIndex the first parameter is 1, the second is 2, ...
 637      * @param x the parameter value
 638      * @exception SQLException if a database access error occurs
 639      */
 640     public void setDate(int parameterIndex, java.sql.Date x)
 641         throws java.sql.SQLException {
 642 
 643         wrappedStatement.setDate(parameterIndex, x);
 644         saveQueryParamValue(parameterIndex, x);
 645     }
 646     /**
 647      * JDBC 2.0
 648      *
 649      * Sets the designated parameter to a java.sql.Date value,
 650      * using the given <code>Calendar</code> object.  The driver uses
 651      * the <code>Calendar</code> object to construct an SQL DATE,
 652      * which the driver then sends to the database.  With a
 653      * a <code>Calendar</code> object, the driver can calculate the date
 654      * taking into account a custom timezone and locale.  If no
 655      * <code>Calendar</code> object is specified, the driver uses the default
 656      * timezone and locale.
 657      *
 658      * @param parameterIndex the first parameter is 1, the second is 2, ...
 659      * @param x the parameter value
 660      * @param cal the <code>Calendar</code> object the driver will use
 661      *            to construct the date
 662      * @exception SQLException if a database access error occurs
 663      */
 664     public void setDate(
 665         int parameterIndex,
 666         java.sql.Date x,
 667         java.util.Calendar cal)
 668         throws java.sql.SQLException {
 669         wrappedStatement.setDate(parameterIndex, x, cal);
 670         saveQueryParamValue(parameterIndex, x);
 671     }
 672     /**
 673      * Sets the designated parameter to a Java double value.  The driver converts this
 674      * to an SQL DOUBLE value when it sends it to the database.
 675      *
 676      * @param parameterIndex the first parameter is 1, the second is 2, ...
 677      * @param x the parameter value
 678      * @exception SQLException if a database access error occurs
 679      */
 680     public void setDouble(int parameterIndex, double x)
 681         throws java.sql.SQLException {
 682         wrappedStatement.setDouble(parameterIndex, x);
 683         saveQueryParamValue(parameterIndex, new Double(x));
 684     }
 685     /**
 686      * Sets escape processing on or off.
 687      * If escape scanning is on (the default), the driver will do
 688      * escape substitution before sending the SQL to the database.
 689      *
 690      * Note: Since prepared statements have usually been parsed prior
 691      * to making this call, disabling escape processing for prepared
 692      * statements will have no effect.
 693      *
 694      * @param enable true to enable; false to disable
 695      * @exception SQLException if a database access error occurs
 696      */
 697     public void setEscapeProcessing(boolean enable)
 698         throws java.sql.SQLException {
 699         wrappedStatement.setEscapeProcessing(enable);
 700 
 701     }
 702     /**
 703      * JDBC 2.0
 704      *
 705      * Gives the driver a hint as to the direction in which
 706      * the rows in a result set
 707      * will be processed. The hint applies only to result sets created
 708      * using this Statement object.  The default value is
 709      * ResultSet.FETCH_FORWARD.
 710      * <p>Note that this method sets the default fetch direction for
 711      * result sets generated by this <code>Statement</code> object.
 712      * Each result set has its own methods for getting and setting
 713      * its own fetch direction.
 714      * @param direction the initial direction for processing rows
 715      * @exception SQLException if a database access error occurs
 716      * or the given direction
 717      * is not one of ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or
 718      * ResultSet.FETCH_UNKNOWN
 719      */
 720     public void setFetchDirection(int direction) throws java.sql.SQLException {
 721         wrappedStatement.setFetchDirection(direction);
 722     }
 723     /**
 724      * JDBC 2.0
 725      *
 726      * Gives the JDBC driver a hint as to the number of rows that should
 727      * be fetched from the database when more rows are needed.  The number
 728      * of rows specified affects only result sets created using this
 729      * statement. If the value specified is zero, then the hint is ignored.
 730      * The default value is zero.
 731      *
 732      * @param rows the number of rows to fetch
 733      * @exception SQLException if a database access error occurs, or the
 734      * condition 0 <= rows <= this.getMaxRows() is not satisfied.
 735      */
 736     public void setFetchSize(int rows) throws java.sql.SQLException {
 737         wrappedStatement.setFetchSize(rows);
 738     }
 739     /**
 740      * Sets the designated parameter to a Java float value.  The driver converts this
 741      * to an SQL FLOAT value when it sends it to the database.
 742      *
 743      * @param parameterIndex the first parameter is 1, the second is 2, ...
 744      * @param x the parameter value
 745      * @exception SQLException if a database access error occurs
 746      */
 747     public void setFloat(int parameterIndex, float x)
 748         throws java.sql.SQLException {
 749         wrappedStatement.setFloat(parameterIndex, x);
 750         saveQueryParamValue(parameterIndex, new Float(x));
 751 
 752     }
 753     /**
 754      * Sets the designated parameter to a Java int value.  The driver converts this
 755      * to an SQL INTEGER value when it sends it to the database.
 756      *
 757      * @param parameterIndex the first parameter is 1, the second is 2, ...
 758      * @param x the parameter value
 759      * @exception SQLException if a database access error occurs
 760      */
 761     public void setInt(int parameterIndex, int x)
 762         throws java.sql.SQLException {
 763         wrappedStatement.setInt(parameterIndex, x);
 764         saveQueryParamValue(parameterIndex, new Integer(x));
 765     }
 766     /**
 767      * Sets the designated parameter to a Java long value.  The driver converts this
 768      * to an SQL BIGINT value when it sends it to the database.
 769      *
 770      * @param parameterIndex the first parameter is 1, the second is 2, ...
 771      * @param x the parameter value
 772      * @exception SQLException if a database access error occurs
 773      */
 774     public void setLong(int parameterIndex, long x)
 775         throws java.sql.SQLException {
 776         wrappedStatement.setLong(parameterIndex, x);
 777         saveQueryParamValue(parameterIndex, new Long(x));
 778 
 779     }
 780     /**
 781      * Sets the limit for the maximum number of bytes in a column to
 782      * the given number of bytes.  This is the maximum number of bytes
 783      * that can be returned for any column value.  This limit applies
 784      * only to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and
 785      * LONGVARCHAR fields.  If the limit is exceeded, the excess data
 786      * is silently discarded. For maximum portability, use values
 787      * greater than 256.
 788      *
 789      * @param max the new max column size limit; zero means unlimited
 790      * @exception SQLException if a database access error occurs
 791      */
 792     public void setMaxFieldSize(int max) throws java.sql.SQLException {
 793         wrappedStatement.setMaxFieldSize(max);
 794 
 795     }
 796     /**
 797      * Sets the limit for the maximum number of rows that any
 798      * ResultSet can contain to the given number.
 799      * If the limit is exceeded, the excess
 800      * rows are silently dropped.
 801      *
 802      * @param max the new max rows limit; zero means unlimited
 803      * @exception SQLException if a database access error occurs
 804      */
 805     public void setMaxRows(int max) throws java.sql.SQLException {
 806         wrappedStatement.setMaxRows(max);
 807     }
 808     /**
 809      * Sets the designated parameter to SQL NULL.
 810      *
 811      * <P><B>Note:</B> You must specify the parameter's SQL type.
 812      *
 813      * @param parameterIndex the first parameter is 1, the second is 2, ...
 814      * @param sqlType the SQL type code defined in java.sql.Types
 815      * @exception SQLException if a database access error occurs
 816      */
 817     public void setNull(int parameterIndex, int sqlType)
 818         throws java.sql.SQLException {
 819         wrappedStatement.setNull(parameterIndex, sqlType);
 820         saveQueryParamValue(parameterIndex, null);
 821     }
 822     /**
 823      * JDBC 2.0
 824      *
 825      * Sets the designated parameter to SQL NULL.  This version of setNull should
 826      * be used for user-named types and REF type parameters.  Examples
 827      * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
 828      * named array types.
 829      *
 830      * <P><B>Note:</B> To be portable, applications must give the
 831      * SQL type code and the fully-qualified SQL type name when specifying
 832      * a NULL user-defined or REF parameter.  In the case of a user-named type
 833      * the name is the type name of the parameter itself.  For a REF
 834      * parameter the name is the type name of the referenced type.  If
 835      * a JDBC driver does not need the type code or type name information,
 836      * it may ignore it.
 837      *
 838      * Although it is intended for user-named and Ref parameters,
 839      * this method may be used to set a null parameter of any JDBC type.
 840      * If the parameter does not have a user-named or REF type, the given
 841      * typeName is ignored.
 842      *
 843      *
 844      * @param parameterIndex the first parameter is 1, the second is 2, ...
 845      * @param sqlType a value from java.sql.Types
 846      * @param typeName the fully-qualified name of an SQL user-named type,
 847      *  ignored if the parameter is not a user-named type or REF
 848      * @exception SQLException if a database access error occurs
 849      */
 850     public void setNull(int paramIndex, int sqlType, String typeName)
 851         throws java.sql.SQLException {
 852         wrappedStatement.setNull(paramIndex, sqlType, typeName);
 853         saveQueryParamValue(paramIndex, null);
 854 
 855     }
 856     /**
 857      * <p>Sets the value of a parameter using an object; use the
 858      * java.lang equivalent objects for integral values.
 859      *
 860      * <p>The JDBC specification specifies a standard mapping from
 861      * Java Object types to SQL types.  The given argument java object
 862      * will be converted to the corresponding SQL type before being
 863      * sent to the database.
 864      *
 865      * <p>Note that this method may be used to pass datatabase-
 866      * specific abstract data types, by using a Driver-specific Java
 867      * type.
 868      *
 869      * If the object is of a class implementing SQLData,
 870      * the JDBC driver should call its method <code>writeSQL</code> to write it
 871      * to the SQL data stream.
 872      * If, on the other hand, the object is of a class implementing
 873      * Ref, Blob, Clob, Struct,
 874      * or Array, then the driver should pass it to the database as a value of the
 875      * corresponding SQL type.
 876      *
 877      * This method throws an exception if there is an ambiguity, for example, if the
 878      * object is of a class implementing more than one of those interfaces.
 879      *
 880      * @param parameterIndex the first parameter is 1, the second is 2, ...
 881      * @param x the object containing the input parameter value
 882      * @exception SQLException if a database access error occurs
 883      */
 884     public void setObject(int parameterIndex, Object x)
 885         throws java.sql.SQLException {
 886         wrappedStatement.setObject(parameterIndex, x);
 887         saveQueryParamValue(parameterIndex, x);
 888     }
 889     /**
 890          * Sets the value of the designated parameter with the given object.
 891          * This method is like setObject above, except that it assumes a scale of zero.
 892          *
 893          * @param parameterIndex the first parameter is 1, the second is 2, ...
 894          * @param x the object containing the input parameter value
 895          * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
 896          *                      sent to the database
 897          * @exception SQLException if a database access error occurs
 898          */
 899     public void setObject(int parameterIndex, Object x, int targetSqlType)
 900         throws java.sql.SQLException {
 901         wrappedStatement.setObject(parameterIndex, x, targetSqlType);
 902         saveQueryParamValue(parameterIndex, x);
 903     }
 904     /**
 905      * <p>Sets the value of a parameter using an object. The second
 906      * argument must be an object type; for integral values, the
 907      * java.lang equivalent objects should be used.
 908      *
 909      * <p>The given Java object will be converted to the targetSqlType
 910      * before being sent to the database.
 911      *
 912      * If the object has a custom mapping (is of a class implementing SQLData),
 913      * the JDBC driver should call its method <code>writeSQL</code> to write it
 914      * to the SQL data stream.
 915      * If, on the other hand, the object is of a class implementing
 916      * Ref, Blob, Clob, Struct,
 917      * or Array, the driver should pass it to the database as a value of the
 918      * corresponding SQL type.
 919      *
 920      * <p>Note that this method may be used to pass datatabase-
 921      * specific abstract data types.
 922      *
 923      * @param parameterIndex the first parameter is 1, the second is 2, ...
 924      * @param x the object containing the input parameter value
 925      * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
 926      * sent to the database. The scale argument may further qualify this type.
 927      * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
 928      *          this is the number of digits after the decimal point.  For all other
 929      *          types, this value will be ignored.
 930      * @exception SQLException if a database access error occurs
 931      * @see Types
 932      */
 933     public void setObject(
 934         int parameterIndex,
 935         Object x,
 936         int targetSqlType,
 937         int scale)
 938         throws java.sql.SQLException {
 939 
 940         wrappedStatement.setObject(parameterIndex, x, targetSqlType, scale);
 941         saveQueryParamValue(parameterIndex, x);
 942     }
 943     /**
 944      * Sets the number of seconds the driver will
 945      * wait for a Statement to execute to the given number of seconds.
 946      * If the limit is exceeded, a SQLException is thrown.
 947      *
 948      * @param seconds the new query timeout limit in seconds; zero means
 949      * unlimited
 950      * @exception SQLException if a database access error occurs
 951      */
 952     public void setQueryTimeout(int seconds) throws java.sql.SQLException {
 953         wrappedStatement.setQueryTimeout(seconds);
 954     }
 955     /**
 956      * JDBC 2.0
 957      *
 958      * Sets a REF(&lt;structured-type&gt;) parameter.
 959      *
 960      * @param i the first parameter is 1, the second is 2, ...
 961      * @param x an object representing data of an SQL REF Type
 962      * @exception SQLException if a database access error occurs
 963      */
 964     public void setRef(int i, java.sql.Ref x) throws java.sql.SQLException {
 965         wrappedStatement.setRef(i, x);
 966         saveQueryParamValue(i, x);
 967 
 968     }
 969     /**
 970      * Sets the designated parameter to a Java short value.  The driver converts this
 971      * to an SQL SMALLINT value when it sends it to the database.
 972      *
 973      * @param parameterIndex the first parameter is 1, the second is 2, ...
 974      * @param x the parameter value
 975      * @exception SQLException if a database access error occurs
 976      */
 977     public void setShort(int parameterIndex, short x)
 978         throws java.sql.SQLException {
 979         wrappedStatement.setShort(parameterIndex, x);
 980         saveQueryParamValue(parameterIndex, new Integer(x));
 981     }
 982     /**
 983      * Sets the designated parameter to a Java String value.  The driver converts this
 984      * to an SQL VARCHAR or LONGVARCHAR value (depending on the argument's
 985      * size relative to the driver's limits on VARCHARs) when it sends
 986      * it to the database.
 987      *
 988      * @param parameterIndex the first parameter is 1, the second is 2, ...
 989      * @param x the parameter value
 990      * @exception SQLException if a database access error occurs
 991      */
 992     public void setString(int parameterIndex, String x)
 993         throws java.sql.SQLException {
 994 
 995         wrappedStatement.setString(parameterIndex, x);
 996         saveQueryParamValue(parameterIndex, x);
 997     }
 998     /**
 999      * Sets the designated parameter to a java.sql.Time value.  The driver converts this
1000      * to an SQL TIME value when it sends it to the database.
1001      *
1002      * @param parameterIndex the first parameter is 1, the second is 2, ...
1003      * @param x the parameter value
1004      * @exception SQLException if a database access error occurs
1005      */
1006     public void setTime(int parameterIndex, java.sql.Time x)
1007         throws java.sql.SQLException {
1008         wrappedStatement.setTime(parameterIndex, x);
1009         saveQueryParamValue(parameterIndex, x);
1010     }
1011     /**
1012      * JDBC 2.0
1013      *
1014      * Sets the designated parameter to a java.sql.Time value,
1015      * using the given <code>Calendar</code> object.  The driver uses
1016      * the <code>Calendar</code> object to construct an SQL TIME,
1017      * which the driver then sends to the database.  With a
1018      * a <code>Calendar</code> object, the driver can calculate the time
1019      * taking into account a custom timezone and locale.  If no
1020      * <code>Calendar</code> object is specified, the driver uses the default
1021      * timezone and locale.
1022      *
1023      * @param parameterIndex the first parameter is 1, the second is 2, ...
1024      * @param x the parameter value
1025      * @param cal the <code>Calendar</code> object the driver will use
1026      *            to construct the time
1027      * @exception SQLException if a database access error occurs
1028      */
1029     public void setTime(
1030         int parameterIndex,
1031         java.sql.Time x,
1032         java.util.Calendar cal)
1033         throws java.sql.SQLException {
1034         wrappedStatement.setTime(parameterIndex, x, cal);
1035         saveQueryParamValue(parameterIndex, x);
1036 
1037     }
1038     /**
1039      * Sets the designated parameter to a java.sql.Timestamp value.  The driver
1040      * converts this to an SQL TIMESTAMP value when it sends it to the
1041      * database.
1042      *
1043      * @param parameterIndex the first parameter is 1, the second is 2, ...
1044      * @param x the parameter value
1045      * @exception SQLException if a database access error occurs
1046      */
1047     public void setTimestamp(int parameterIndex, java.sql.Timestamp x)
1048         throws java.sql.SQLException {
1049         wrappedStatement.setTimestamp(parameterIndex, x);
1050         saveQueryParamValue(parameterIndex, x);
1051     }
1052     /**
1053      * JDBC 2.0
1054      *
1055      * Sets the designated parameter to a java.sql.Timestamp value,
1056      * using the given <code>Calendar</code> object.  The driver uses
1057      * the <code>Calendar</code> object to construct an SQL TIMESTAMP,
1058      * which the driver then sends to the database.  With a
1059      * a <code>Calendar</code> object, the driver can calculate the timestamp
1060      * taking into account a custom timezone and locale.  If no
1061      * <code>Calendar</code> object is specified, the driver uses the default
1062      * timezone and locale.
1063      *
1064      * @param parameterIndex the first parameter is 1, the second is 2, ...
1065      * @param x the parameter value
1066      * @param cal the <code>Calendar</code> object the driver will use
1067      *            to construct the timestamp
1068      * @exception SQLException if a database access error occurs
1069      */
1070     public void setTimestamp(
1071         int parameterIndex,
1072         java.sql.Timestamp x,
1073         java.util.Calendar cal)
1074         throws java.sql.SQLException {
1075         wrappedStatement.setTimestamp(parameterIndex, x, cal);
1076         saveQueryParamValue(parameterIndex, x);
1077     }
1078     /**
1079      * Sets the designated parameter to the given input stream, which will have
1080      * the specified number of bytes.
1081      * When a very large UNICODE value is input to a LONGVARCHAR
1082      * parameter, it may be more practical to send it via a
1083      * java.io.InputStream. JDBC will read the data from the stream
1084      * as needed, until it reaches end-of-file.  The JDBC driver will
1085      * do any necessary conversion from UNICODE to the database char format.
1086      * The byte format of the Unicode stream must be Java UTF-8, as
1087      * defined in the Java Virtual Machine Specification.
1088      *
1089      * <P><B>Note:</B> This stream object can either be a standard
1090      * Java stream object or your own subclass that implements the
1091      * standard interface.
1092      *
1093      * @param parameterIndex the first parameter is 1, the second is 2, ...
1094      * @param x the java input stream which contains the
1095      * UNICODE parameter value
1096      * @param length the number of bytes in the stream
1097      * @exception SQLException if a database access error occurs
1098      * @deprecated
1099      */
1100     public void setUnicodeStream(
1101         int parameterIndex,
1102         java.io.InputStream x,
1103         int length)
1104         throws java.sql.SQLException {
1105         wrappedStatement.setUnicodeStream(parameterIndex, x, length);
1106         saveQueryParamValue(parameterIndex, x);
1107     }
1108 
1109     /**
1110      * Returns the sql statement string (question marks replaced with set parameter values)
1111      * that will be (or has been) executed by the {@link java.sql.PreparedStatement PreparedStatement} that this
1112      * <code>LoggableStatement</code> is a wrapper for.
1113      * <p>
1114      * @return java.lang.String the statemant represented by this <code>LoggableStatement</code>
1115      */
1116     public String getQueryString() {
1117 
1118         StringBuffer buf = new StringBuffer();
1119         int qMarkCount = 0;
1120         ArrayList chunks = new ArrayList();
1121         StringTokenizer tok = new StringTokenizer(sqlTemplate+" ", "?");
1122         while (tok.hasMoreTokens()) {
1123             String oneChunk = tok.nextToken();
1124             buf.append(oneChunk);
1125 
1126             try {
1127                 Object value;
1128                 if (parameterValues.size() > 1 + qMarkCount) {
1129                     value = parameterValues.get(1 + qMarkCount++);
1130                 } else {
1131                     if (tok.hasMoreTokens()) {
1132                         value = null;
1133                     } else {
1134                         value = "";
1135                     }
1136                 }
1137                 buf.append("" + value);
1138             } catch (Throwable e) {
1139                 buf.append(
1140                     "ERROR WHEN PRODUCING QUERY STRING FOR LOG."
1141                         + e.toString());
1142                 // catch this without whining, if this fails the only thing wrong is probably this class
1143             }
1144         }
1145         return buf.toString().trim();
1146     }
1147 
1148     /**
1149      * Saves the parameter value <code>obj</code> for the specified <code>position</code> for use in logging output
1150      *
1151      * @param position position (starting at 1) of the parameter to save
1152      * @param obj java.lang.Object the parameter value to save
1153      */
1154     private void saveQueryParamValue(int position, Object obj) {
1155         String strValue;
1156         if (obj instanceof String || obj instanceof Date) {
1157             // if we have a String or Date , include '' in the saved value
1158             strValue = "'" + obj + "'";
1159         } else {
1160 
1161             if (obj == null) {
1162                 // convert null to the string null
1163                 strValue = "null";
1164             } else {
1165                 // unknown object (includes all Numbers), just call toString
1166                 strValue = obj.toString();
1167             }
1168         }
1169 
1170         // if we are setting a position larger than current size of parameterValues, first make it larger
1171         while (position >= parameterValues.size()) {
1172             parameterValues.add(null);
1173         }
1174         // save the parameter
1175         parameterValues.set(position, strValue);
1176     }
1177 
1178     @Override
1179     public boolean getMoreResults(int current) throws SQLException {
1180         // TODO Auto-generated method stub
1181         return false;
1182     }
1183 
1184     @Override
1185     public ResultSet getGeneratedKeys() throws SQLException {
1186         // TODO Auto-generated method stub
1187         return null;
1188     }
1189 
1190     @Override
1191     public int executeUpdate(String sql, int autoGeneratedKeys)
1192             throws SQLException {
1193         // TODO Auto-generated method stub
1194         return 0;
1195     }
1196 
1197     @Override
1198     public int executeUpdate(String sql, int[] columnIndexes)
1199             throws SQLException {
1200         // TODO Auto-generated method stub
1201         return 0;
1202     }
1203 
1204     @Override
1205     public int executeUpdate(String sql, String[] columnNames)
1206             throws SQLException {
1207         // TODO Auto-generated method stub
1208         return 0;
1209     }
1210 
1211     @Override
1212     public boolean execute(String sql, int autoGeneratedKeys)
1213             throws SQLException {
1214         // TODO Auto-generated method stub
1215         return false;
1216     }
1217 
1218     @Override
1219     public boolean execute(String sql, int[] columnIndexes) throws SQLException {
1220         // TODO Auto-generated method stub
1221         return false;
1222     }
1223 
1224     @Override
1225     public boolean execute(String sql, String[] columnNames)
1226             throws SQLException {
1227         // TODO Auto-generated method stub
1228         return false;
1229     }
1230 
1231     @Override
1232     public int getResultSetHoldability() throws SQLException {
1233         // TODO Auto-generated method stub
1234         return 0;
1235     }
1236 
1237     @Override
1238     public boolean isClosed() throws SQLException {
1239         // TODO Auto-generated method stub
1240         return false;
1241     }
1242 
1243     @Override
1244     public void setPoolable(boolean poolable) throws SQLException {
1245         // TODO Auto-generated method stub
1246         
1247     }
1248 
1249     @Override
1250     public boolean isPoolable() throws SQLException {
1251         // TODO Auto-generated method stub
1252         return false;
1253     }
1254 
1255     @Override
1256     public void closeOnCompletion() throws SQLException {
1257         // TODO Auto-generated method stub
1258         
1259     }
1260 
1261     @Override
1262     public boolean isCloseOnCompletion() throws SQLException {
1263         // TODO Auto-generated method stub
1264         return false;
1265     }
1266 
1267     @Override
1268     public <T> T unwrap(Class<T> iface) throws SQLException {
1269         // TODO Auto-generated method stub
1270         return null;
1271     }
1272 
1273     @Override
1274     public boolean isWrapperFor(Class<?> iface) throws SQLException {
1275         // TODO Auto-generated method stub
1276         return false;
1277     }
1278 
1279     @Override
1280     public void setURL(int parameterIndex, URL x) throws SQLException {
1281         // TODO Auto-generated method stub
1282         
1283     }
1284 
1285     @Override
1286     public ParameterMetaData getParameterMetaData() throws SQLException {
1287         // TODO Auto-generated method stub
1288         return null;
1289     }
1290 
1291     @Override
1292     public void setRowId(int parameterIndex, RowId x) throws SQLException {
1293         // TODO Auto-generated method stub
1294         
1295     }
1296 
1297     @Override
1298     public void setNString(int parameterIndex, String value)
1299             throws SQLException {
1300         // TODO Auto-generated method stub
1301         
1302     }
1303 
1304     @Override
1305     public void setNCharacterStream(int parameterIndex, Reader value,
1306             long length) throws SQLException {
1307         // TODO Auto-generated method stub
1308         
1309     }
1310 
1311     @Override
1312     public void setNClob(int parameterIndex, NClob value) throws SQLException {
1313         // TODO Auto-generated method stub
1314         
1315     }
1316 
1317     @Override
1318     public void setClob(int parameterIndex, Reader reader, long length)
1319             throws SQLException {
1320         // TODO Auto-generated method stub
1321         
1322     }
1323 
1324     @Override
1325     public void setBlob(int parameterIndex, InputStream inputStream, long length)
1326             throws SQLException {
1327         // TODO Auto-generated method stub
1328         
1329     }
1330 
1331     @Override
1332     public void setNClob(int parameterIndex, Reader reader, long length)
1333             throws SQLException {
1334         // TODO Auto-generated method stub
1335         
1336     }
1337 
1338     @Override
1339     public void setSQLXML(int parameterIndex, SQLXML xmlObject)
1340             throws SQLException {
1341         // TODO Auto-generated method stub
1342         
1343     }
1344 
1345     @Override
1346     public void setAsciiStream(int parameterIndex, InputStream x, long length)
1347             throws SQLException {
1348         // TODO Auto-generated method stub
1349         
1350     }
1351 
1352     @Override
1353     public void setBinaryStream(int parameterIndex, InputStream x, long length)
1354             throws SQLException {
1355         // TODO Auto-generated method stub
1356         
1357     }
1358 
1359     @Override
1360     public void setCharacterStream(int parameterIndex, Reader reader,
1361             long length) throws SQLException {
1362         // TODO Auto-generated method stub
1363         
1364     }
1365 
1366     @Override
1367     public void setAsciiStream(int parameterIndex, InputStream x)
1368             throws SQLException {
1369         // TODO Auto-generated method stub
1370         
1371     }
1372 
1373     @Override
1374     public void setBinaryStream(int parameterIndex, InputStream x)
1375             throws SQLException {
1376         // TODO Auto-generated method stub
1377         
1378     }
1379 
1380     @Override
1381     public void setCharacterStream(int parameterIndex, Reader reader)
1382             throws SQLException {
1383         // TODO Auto-generated method stub
1384         
1385     }
1386 
1387     @Override
1388     public void setNCharacterStream(int parameterIndex, Reader value)
1389             throws SQLException {
1390         // TODO Auto-generated method stub
1391         
1392     }
1393 
1394     @Override
1395     public void setClob(int parameterIndex, Reader reader) throws SQLException {
1396         // TODO Auto-generated method stub
1397         
1398     }
1399 
1400     @Override
1401     public void setBlob(int parameterIndex, InputStream inputStream)
1402             throws SQLException {
1403         // TODO Auto-generated method stub
1404         
1405     }
1406 
1407     @Override
1408     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
1409         // TODO Auto-generated method stub
1410         
1411     }
1412 }