|
|
Glassfish example source code file (PreparedStatementWrapper.java)
This example Glassfish source code file (PreparedStatementWrapper.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The Glassfish PreparedStatementWrapper.java source code
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.gjc.spi.base;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
/**
* Abstract class for wrapping PreparedStatement<br>
*/
public abstract class PreparedStatementWrapper extends StatementWrapper implements PreparedStatement {
protected PreparedStatement preparedStatement = null;
private boolean busy = false;
private boolean cached = false;
private int defaultMaxFieldSize;
private int defaultMaxRows;
private int defaultQueryTimeout;
private int defaultFetchDirection;
private int defaultFetchSize;
private int currentMaxFieldSize;
private int currentMaxRows;
private int currentQueryTimeout;
private int currentFetchDirection;
private int currentFetchSize;
private boolean valid = true;
/**
* Abstract class for wrapping PreparedStatement <br>
*
* @param con Connection Wrapper <br>
* @param statement PreparedStatement that is to be wrapped.<br>
* @param cachingEnabled boolean that enabled/ disables caching <br>
* @throws SQLException Exception thrown from underlying statement<br>
*/
public PreparedStatementWrapper(Connection con,
PreparedStatement statement, boolean cachingEnabled) throws SQLException {
super(con, statement);
preparedStatement = statement;
cached = cachingEnabled;
ConnectionHolder wrappedCon = (ConnectionHolder) con;
leakDetector = wrappedCon.getManagedConnection().getLeakDetector();
if (cached) {
defaultQueryTimeout = preparedStatement.getQueryTimeout();
defaultMaxFieldSize = preparedStatement.getMaxFieldSize();
defaultFetchSize = preparedStatement.getFetchSize();
defaultMaxRows = preparedStatement.getMaxRows();
defaultFetchDirection = preparedStatement.getFetchDirection();
currentQueryTimeout = defaultQueryTimeout;
currentMaxFieldSize = defaultMaxFieldSize;
currentFetchSize = defaultFetchSize;
currentMaxRows = defaultMaxRows;
currentFetchDirection = defaultFetchDirection;
} else {
//Start Statement leak detection
if(leakDetector != null) {
leakDetector.startStatementLeakTracing(preparedStatement, this);
}
}
}
/**
* Executes the SQL statement in this <code>PreparedStatement object,
* which must be an SQL <code>INSERT, UPDATE or
* <code>DELETE statement; or an SQL statement that returns nothing,
* such as a DDL statement.
*
* @return either (1) the row count for <code>INSERT, UPDATE,
* or <code>DELETE statements
* or (2) 0 for SQL statements that return nothing
* @throws java.sql.SQLException if a database access error occurs or the SQL
* statement returns a <code>ResultSet object
*/
public int executeUpdate() throws SQLException {
return preparedStatement.executeUpdate();
}
/**
* Sets the designated parameter to SQL <code>NULL.
* <p/>
* <P>Note: You must specify the parameter's SQL type.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param sqlType the SQL type code defined in <code>java.sql.Types
* @throws java.sql.SQLException if a database access error occurs
*/
public void setNull(int parameterIndex, int sqlType) throws SQLException {
preparedStatement.setNull(parameterIndex, sqlType);
}
/**
* Sets the designated parameter to the given Java <code>boolean value.
* The driver converts this
* to an SQL <code>BIT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
preparedStatement.setBoolean(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>byte value.
* The driver converts this
* to an SQL <code>TINYINT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setByte(int parameterIndex, byte x) throws SQLException {
preparedStatement.setByte(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>short value.
* The driver converts this
* to an SQL <code>SMALLINT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setShort(int parameterIndex, short x) throws SQLException {
preparedStatement.setShort(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>int value.
* The driver converts this
* to an SQL <code>INTEGER value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setInt(int parameterIndex, int x) throws SQLException {
preparedStatement.setInt(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>long value.
* The driver converts this
* to an SQL <code>BIGINT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setLong(int parameterIndex, long x) throws SQLException {
preparedStatement.setLong(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>float value.
* The driver converts this
* to an SQL <code>FLOAT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setFloat(int parameterIndex, float x) throws SQLException {
preparedStatement.setFloat(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>double value.
* The driver converts this
* to an SQL <code>DOUBLE value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setDouble(int parameterIndex, double x) throws SQLException {
preparedStatement.setDouble(parameterIndex, x);
}
/**
* Sets the designated parameter to the given <code>java.math.BigDecimal value.
* The driver converts this to an SQL <code>NUMERIC value when
* it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
preparedStatement.setBigDecimal(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java <code>String value.
* The driver converts this
* to an SQL <code>VARCHAR or LONGVARCHAR value
* (depending on the argument's
* size relative to the driver's limits on <code>VARCHAR values)
* when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setString(int parameterIndex, String x) throws SQLException {
preparedStatement.setString(parameterIndex, x);
}
/**
* Sets the designated parameter to the given Java array of bytes. The driver converts
* this to an SQL <code>VARBINARY or LONGVARBINARY
* (depending on the argument's size relative to the driver's limits on
* <code>VARBINARY values) when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBytes(int parameterIndex, byte x[]) throws SQLException {
preparedStatement.setBytes(parameterIndex, x);
}
/**
* Sets the designated parameter to the given <code>java.sql.Date value.
* The driver converts this
* to an SQL <code>DATE value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setDate(int parameterIndex, Date x) throws SQLException {
preparedStatement.setDate(parameterIndex, x);
}
/**
* Sets the designated parameter to the given <code>java.sql.Time value.
* The driver converts this
* to an SQL <code>TIME value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setTime(int parameterIndex, Time x) throws SQLException {
preparedStatement.setTime(parameterIndex, x);
}
/**
* Sets the designated parameter to the given <code>java.sql.Timestamp value.
* The driver
* converts this to an SQL <code>TIMESTAMP value when it sends it to the
* database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
preparedStatement.setTimestamp(parameterIndex, x);
}
/**
* Sets the designated parameter to the given input stream, which will have
* the specified number of bytes.
* When a very large ASCII value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream. Data will be read from the stream
* as needed until end-of-file is reached. The JDBC driver will
* do any necessary conversion from ASCII to the database char format.
* <p/>
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the Java input stream that contains the ASCII parameter value
* @param length the number of bytes in the stream
* @throws java.sql.SQLException if a database access error occurs
*/
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
preparedStatement.setAsciiStream(parameterIndex, x, length);
}
/**
* Sets the designated parameter to the given input stream, which
* will have the specified number of bytes. A Unicode character has
* two bytes, with the first byte being the high byte, and the second
* being the low byte.
* <p/>
* When a very large Unicode value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream object. The data will be read from the
* stream as needed until end-of-file is reached. The JDBC driver will
* do any necessary conversion from Unicode to the database char format.
* <p/>
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x a <code>java.io.InputStream object that contains the
* Unicode parameter value as two-byte Unicode characters
* @param length the number of bytes in the stream
* @throws java.sql.SQLException if a database access error occurs
* @deprecated
*/
@Deprecated
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
preparedStatement.setUnicodeStream(parameterIndex, x, length);
}
/**
* Sets the designated parameter to the given input stream, which will have
* the specified number of bytes.
* When a very large binary value is input to a <code>LONGVARBINARY
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream object. The data will be read from the
* stream as needed until end-of-file is reached.
* <p/>
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the java input stream which contains the binary parameter value
* @param length the number of bytes in the stream
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
preparedStatement.setBinaryStream(parameterIndex, x, length);
}
/**
* Clears the current parameter values immediately.
* <P>In general, parameter values remain in force for repeated use of a
* statement. Setting a parameter value automatically clears its
* previous value. However, in some cases it is useful to immediately
* release the resources used by the current parameter values; this can
* be done by calling the method <code>clearParameters.
*
* @throws java.sql.SQLException if a database access error occurs
*/
public void clearParameters() throws SQLException {
preparedStatement.clearParameters();
}
/**
* <p>Sets the value of the designated parameter with the given object. The second
* argument must be an object type; for integral values, the
* <code>java.lang equivalent objects should be used.
* <p/>
* <p>The given Java object will be converted to the given targetSqlType
* before being sent to the database.
* <p/>
* If the object has a custom mapping (is of a class implementing the
* interface <code>SQLData),
* the JDBC driver should call the method <code>SQLData.writeSQL to
* write it to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* <code>Ref, Blob, Clob, Struct,
* or <code>Array, the driver should pass it to the database as a
* value of the corresponding SQL type.
* <p/>
* <p>Note that this method may be used to pass database-specific
* abstract data types.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database. The scale argument may further qualify this type.
* @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
* this is the number of digits after the decimal point. For all other
* types, this value will be ignored.
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
*/
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
preparedStatement.setObject(parameterIndex, x, targetSqlType, scale);
}
/**
* Sets the value of the designated parameter with the given object.
* This method is like the method <code>setObject
* above, except that it assumes a scale of zero.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database
* @throws java.sql.SQLException if a database access error occurs
*/
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
preparedStatement.setObject(parameterIndex, x, targetSqlType);
}
/**
* <p>Sets the value of the designated parameter using the given object.
* The second parameter must be of type <code>Object; therefore, the
* <code>java.lang equivalent objects should be used for built-in types.
* <p/>
* <p>The JDBC specification specifies a standard mapping from
* Java <code>Object types to SQL types. The given argument
* will be converted to the corresponding SQL type before being
* sent to the database.
* <p/>
* <p>Note that this method may be used to pass datatabase-
* specific abstract data types, by using a driver-specific Java
* type.
* <p/>
* If the object is of a class implementing the interface <code>SQLData,
* the JDBC driver should call the method <code>SQLData.writeSQL
* to write it to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* <code>Ref, Blob, Clob, Struct,
* or <code>Array, the driver should pass it to the database as a
* value of the corresponding SQL type.
* <p/>
* This method throws an exception if there is an ambiguity, for example, if the
* object is of a class implementing more than one of the interfaces named above.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the object containing the input parameter value
* @throws java.sql.SQLException if a database access error occurs or the type
* of the given object is ambiguous
*/
public void setObject(int parameterIndex, Object x) throws SQLException {
preparedStatement.setObject(parameterIndex, x);
}
/**
* Executes the SQL statement in this <code>PreparedStatement object,
* which may be any kind of SQL statement.
* Some prepared statements return multiple results; the <code>execute
* method handles these complex statements as well as the simpler
* form of statements handled by the methods <code>executeQuery
* and <code>executeUpdate.
* <p/>
* The <code>execute method returns a boolean to
* indicate the form of the first result. You must call either the method
* <code>getResultSet or getUpdateCount
* to retrieve the result; you must call <code>getMoreResults to
* move to any subsequent result(s).
*
* @return <code>true if the first result is a ResultSet
* object; <code>false if the first result is an update
* count or there is no result
* @throws java.sql.SQLException if a database access error occurs or an argument
* is supplied to this method
* @see java.sql.Statement#execute
* @see java.sql.Statement#getResultSet
* @see java.sql.Statement#getUpdateCount
* @see java.sql.Statement#getMoreResults
*/
public boolean execute() throws SQLException {
return preparedStatement.execute();
}
/**
* Adds a set of parameters to this <code>PreparedStatement
* object's batch of commands.
*
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Statement#addBatch
* @since 1.2
*/
public void addBatch() throws SQLException {
preparedStatement.addBatch();
}
/**
* Sets the designated parameter to the given <code>Reader
* object, which is the given number of characters long.
* When a very large UNICODE value is input to a <code>LONGVARCHAR
* parameter, it may be more practical to send it via a
* <code>java.io.Reader object. The data will be read from the stream
* as needed until end-of-file is reached. The JDBC driver will
* do any necessary conversion from UNICODE to the database char format.
* <p/>
* <P>Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param reader the <code>java.io.Reader object that contains the
* Unicode data
* @param length the number of characters in the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
preparedStatement.setCharacterStream(parameterIndex, reader, length);
}
/**
* Sets the designated parameter to the given
* <code>REF(<structured-type>) value.
* The driver converts this to an SQL <code>REF value when it
* sends it to the database.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x an SQL <code>REF value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setRef(int i, Ref x) throws SQLException {
preparedStatement.setRef(i, x);
}
/**
* Sets the designated parameter to the given <code>Blob object.
* The driver converts this to an SQL <code>BLOB value when it
* sends it to the database.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x a <code>Blob object that maps an SQL BLOB value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setBlob(int i, Blob x) throws SQLException {
preparedStatement.setBlob(i, x);
}
/**
* Sets the designated parameter to the given <code>Clob object.
* The driver converts this to an SQL <code>CLOB value when it
* sends it to the database.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x a <code>Clob object that maps an SQL CLOB value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setClob(int i, Clob x) throws SQLException {
preparedStatement.setClob(i, x);
}
/**
* Sets the designated parameter to the given <code>Array object.
* The driver converts this to an SQL <code>ARRAY value when it
* sends it to the database.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x an <code>Array object that maps an SQL ARRAY value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setArray(int i, Array x) throws SQLException {
preparedStatement.setArray(i, x);
}
/**
* Retrieves a <code>ResultSetMetaData object that contains
* information about the columns of the <code>ResultSet object
* that will be returned when this <code>PreparedStatement object
* is executed.
* <p/>
* Because a <code>PreparedStatement object is precompiled, it is
* possible to know about the <code>ResultSet object that it will
* return without having to execute it. Consequently, it is possible
* to invoke the method <code>getMetaData on a
* <code>PreparedStatement object rather than waiting to execute
* it and then invoking the <code>ResultSet.getMetaData method
* on the <code>ResultSet object that is returned.
* <p/>
* <B>NOTE: Using this method may be expensive for some drivers due
* to the lack of underlying DBMS support.
*
* @return the description of a <code>ResultSet object's columns or
* <code>null if the driver cannot return a
* <code>ResultSetMetaData object
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public ResultSetMetaData getMetaData() throws SQLException {
return preparedStatement.getMetaData();
}
/**
* Sets the designated parameter to the given <code>java.sql.Date value,
* using the given <code>Calendar object. The driver uses
* the <code>Calendar object to construct an SQL DATE value,
* which the driver then sends to the database. With
* a <code>Calendar object, the driver can calculate the date
* taking into account a custom timezone. If no
* <code>Calendar object is specified, the driver uses the default
* timezone, which is that of the virtual machine running the application.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @param cal the <code>Calendar object the driver will use
* to construct the date
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
preparedStatement.setDate(parameterIndex, x, cal);
}
/**
* Sets the designated parameter to the given <code>java.sql.Time value,
* using the given <code>Calendar object. The driver uses
* the <code>Calendar object to construct an SQL TIME value,
* which the driver then sends to the database. With
* a <code>Calendar object, the driver can calculate the time
* taking into account a custom timezone. If no
* <code>Calendar object is specified, the driver uses the default
* timezone, which is that of the virtual machine running the application.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @param cal the <code>Calendar object the driver will use
* to construct the time
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
preparedStatement.setTime(parameterIndex, x, cal);
}
/**
* Sets the designated parameter to the given <code>java.sql.Timestamp value,
* using the given <code>Calendar object. The driver uses
* the <code>Calendar object to construct an SQL TIMESTAMP value,
* which the driver then sends to the database. With a
* <code>Calendar object, the driver can calculate the timestamp
* taking into account a custom timezone. If no
* <code>Calendar object is specified, the driver uses the default
* timezone, which is that of the virtual machine running the application.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @param cal the <code>Calendar object the driver will use
* to construct the timestamp
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
preparedStatement.setTimestamp(parameterIndex, x, cal);
}
/**
* Sets the designated parameter to SQL <code>NULL.
* This version of the method <code>setNull should
* be used for user-defined types and REF type parameters. Examples
* of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
* named array types.
* <p/>
* <P>Note: To be portable, applications must give the
* SQL type code and the fully-qualified SQL type name when specifying
* a NULL user-defined or REF parameter. In the case of a user-defined type
* the name is the type name of the parameter itself. For a REF
* parameter, the name is the type name of the referenced type. If
* a JDBC driver does not need the type code or type name information,
* it may ignore it.
* <p/>
* Although it is intended for user-defined and Ref parameters,
* this method may be used to set a null parameter of any JDBC type.
* If the parameter does not have a user-defined or REF type, the given
* typeName is ignored.
*
* @param paramIndex the first parameter is 1, the second is 2, ...
* @param sqlType a value from <code>java.sql.Types
* @param typeName the fully-qualified name of an SQL user-defined type;
* ignored if the parameter is not a user-defined type or REF
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
preparedStatement.setNull(paramIndex, sqlType, typeName);
}
/**
* Sets the designated parameter to the given <code>java.net.URL value.
* The driver converts this to an SQL <code>DATALINK value
* when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the <code>java.net.URL object to be set
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public void setURL(int parameterIndex, URL x) throws SQLException {
preparedStatement.setURL(parameterIndex, x);
}
/**
* Retrieves the number, types and properties of this
* <code>PreparedStatement object's parameters.
*
* @return a <code>ParameterMetaData object that contains information
* about the number, types and properties of this
* <code>PreparedStatement object's parameters
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.ParameterMetaData
* @since 1.4
*/
public ParameterMetaData getParameterMetaData() throws SQLException {
return preparedStatement.getParameterMetaData();
}
public boolean isBusy() {
return busy;
}
public void setBusy(boolean busy) {
this.busy = busy;
if (busy) {
if (leakDetector != null) {
leakDetector.startStatementLeakTracing(preparedStatement, this);
}
} else {
if (leakDetector != null) {
leakDetector.stopStatementLeakTracing(preparedStatement, this);
if(cached && isMarkedForReclaim()) {
//When caching is on and is marked for reclaim, the statement
//would still remain in cache. Hence mark it as invalid and
//let the client that uses the statement, detect and purge
//it if found as invalid
setValid(false);
}
}
}
}
public boolean getCached() {
return cached;
}
public void close() throws SQLException {
if (!cached) {
//Stop leak tracing
if(leakDetector != null) {
leakDetector.stopStatementLeakTracing(preparedStatement, this);
}
preparedStatement.close();
} else {
//TODO-SC what if Exception is thrown in this block, should there be a way to indicate the
// con. not to use this statement any more ?
clearParameters();
if (defaultQueryTimeout != currentQueryTimeout) {
preparedStatement.setQueryTimeout(defaultQueryTimeout);
currentQueryTimeout = defaultQueryTimeout;
}
if (defaultMaxFieldSize != currentMaxFieldSize) {
preparedStatement.setMaxFieldSize(defaultMaxFieldSize);
currentMaxFieldSize = defaultMaxFieldSize;
}
if (defaultFetchSize != currentFetchSize) {
preparedStatement.setFetchSize(defaultFetchSize);
currentFetchSize = defaultFetchSize;
}
if (defaultMaxRows != currentMaxRows) {
preparedStatement.setMaxRows(defaultMaxRows);
currentMaxRows = defaultMaxRows;
}
if (defaultFetchDirection != currentFetchDirection) {
preparedStatement.setFetchDirection(defaultFetchDirection);
currentFetchDirection = defaultFetchDirection;
}
setBusy(false);
}
}
public void setMaxFieldSize(int max) throws SQLException {
preparedStatement.setMaxFieldSize(max);
if (cached)
currentMaxFieldSize = max;
}
public void setMaxRows(int max) throws SQLException {
preparedStatement.setMaxRows(max);
if (cached)
currentMaxRows = max;
}
public void setQueryTimeout(int seconds) throws SQLException {
preparedStatement.setQueryTimeout(seconds);
if (cached)
currentQueryTimeout = seconds;
}
public void setFetchDirection(int direction) throws SQLException {
preparedStatement.setFetchDirection(direction);
if (cached)
currentFetchDirection = direction;
}
public void setFetchSize(int rows) throws SQLException {
preparedStatement.setFetchSize(rows);
if (cached)
currentFetchSize = rows;
}
public void setCached(boolean cached){
this.cached = cached;
}
public boolean isValid() {
return valid;
}
public void setValid(boolean valid) {
this.valid = valid;
}
}
Other Glassfish examples (source code examples)
Here is a short list of links related to this Glassfish PreparedStatementWrapper.java source code file:
|
The search page
Other Glassfish source code examples at this package level
Click here to learn more about this project
