All Downloads are FREE. Search and download functionalities are using the official Maven repository.

src-main.org.awakefw.commons.jdbc.abstracts.AbstractPreparedStatement Maven / Gradle / Ivy

Go to download

Awake FILE is a secure Open Source framework that allows to program very easily file uploads/downloads and RPC through http. File transfers include powerful features like file chunking and automatic recovery mechanism. Security has been taken into account from the design: server side allows to specify strong security rules in order to protect the files and to secure the RPC calls.

There is a newer version: 3.0
Show newest version
/*
 * This file is part of Awake FILE. 
 * Awake FILE: Easy file upload & download over HTTP with Java.                                    
 * Copyright (C) 2014,  KawanSoft SAS
 * (http://www.kawansoft.com). All rights reserved.                                
 *                                                                               
 * Awake FILE is free software; you can redistribute it and/or                 
 * modify it under the terms of the GNU Lesser General Public                    
 * License as published by the Free Software Foundation; either                  
 * version 2.1 of the License, or (at your option) any later version.            
 *                                                                               
 * Awake FILE is distributed in the hope that it will be useful,               
 * but WITHOUT ANY WARRANTY; without even the implied warranty of                
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             
 * Lesser General Public License for more details.                               
 *                                                                               
 * You should have received a copy of the GNU Lesser General Public              
 * License along with this library; if not, write to the Free Software           
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  
 * 02110-1301  USA
 *
 * Any modifications to this file must keep this entire header
 * intact.
 */
package org.awakefw.commons.jdbc.abstracts;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Types;
import java.util.Calendar;

/**
 * PreparedStatement Wrapper. 
* Implements all the PreparedStatement methods. Usage is exactly the same as a * PreparedStatement. * */ public abstract class AbstractPreparedStatement extends AbstractStatement implements Statement, PreparedStatement { /** SQL JDBC PreparedStatement */ private PreparedStatement preparedStatement = null; /** Flag that says the caller is ConnectionHttp */ private boolean isConnectionHttp = false; /** * Constructor Needed for HTTP usage because there is no real JDBC * Connection * * @param prepStatement * actual PreparedStatement in use to wrap */ public AbstractPreparedStatement(String sql) throws SQLException { isConnectionHttp = true; } /** * Will throw a SQL Exception if calling method is not authorized **/ private void verifyCallAuthorization(String methodName) throws SQLException { if (isConnectionHttp) { throw new SQLException( AbstractConnection.FEATURE_NOT_SUPPORTED_IN_THIS_VERSION + methodName); } } /** * Constructor * * @param preparedStatement * actual PreparedStatement in use to wrap */ public AbstractPreparedStatement(PreparedStatement preparedStatement) throws SQLException { super(preparedStatement); String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement = preparedStatement; } /** * Sets the designated parameter to SQL NULL. * *

* 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 java.sql.Types * @exception SQLException * if a database access error occurs */ public void setNull(int parameterIndex, int sqlType) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setNull(parameterIndex, sqlType); } /** * Sets the designated parameter to the given Java boolean * value. The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setBoolean(int parameterIndex, boolean x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setBoolean(parameterIndex, x); } /** * Sets the designated parameter to the given Java byte value. * The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setByte(int parameterIndex, byte x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setByte(parameterIndex, x); } /** * Sets the designated parameter to the given Java short value. * The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setShort(int parameterIndex, short x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setShort(parameterIndex, x); } /** * Sets the designated parameter to the given Java int value. * The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setInt(int parameterIndex, int x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setInt(parameterIndex, x); } /** * Sets the designated parameter to the given Java long value. * The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setLong(int parameterIndex, long x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setLong(parameterIndex, x); } /** * Sets the designated parameter to the given Java float value. * The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setFloat(int parameterIndex, float x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setFloat(parameterIndex, x); } /** * Sets the designated parameter to the given Java double * value. The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setDouble(int parameterIndex, double x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setDouble(parameterIndex, x); } /** * Sets the designated parameter to the given * java.math.BigDecimal value. The driver converts this to an * SQL 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 * @exception SQLException * if a database access error occurs */ public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setBigDecimal(parameterIndex, x); } /** * Sets the designated parameter to the given Java String * value. The driver converts this to an SQL VARCHAR or * LONGVARCHAR value (depending on the argument's size relative * to the driver's limits on 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 * @exception SQLException * if a database access error occurs */ public void setString(int parameterIndex, String x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setString(parameterIndex, x); } /** * Sets the designated parameter to the given Java array of bytes. The * driver converts this to an SQL VARBINARY or * LONGVARBINARY (depending on the argument's size relative to * the driver's limits on 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 * @exception SQLException * if a database access error occurs */ public void setBytes(int parameterIndex, byte[] x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setBytes(parameterIndex, x); } /** * Sets the designated parameter to the given java.sql.Date * value. The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setDate(int parameterIndex, java.sql.Date x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setDate(parameterIndex, x); } /** * Sets the designated parameter to the given java.sql.Time * value. The driver converts this to an SQL 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 * @exception SQLException * if a database access error occurs */ public void setTime(int parameterIndex, java.sql.Time x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setTime(parameterIndex, x); } /** * Sets the designated parameter to the given * java.sql.Timestamp value. The driver converts this to an SQL * 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 * @exception SQLException * if a database access error occurs */ public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.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 LONGVARCHAR parameter, it may be more practical to send it * via a 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. * *

* 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 * @exception SQLException * if a database access error occurs */ public void setAsciiStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.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. * * When a very large Unicode value is input to a LONGVARCHAR * parameter, it may be more practical to send it via a * 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. * *

* 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 java.io.InputStream object that contains the * Unicode parameter value as two-byte Unicode characters * @param length * the number of bytes in the stream * @exception SQLException * if a database access error occurs * @deprecated */ public void setUnicodeStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.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 LONGVARBINARY parameter, it may be more practical to send * it via a java.io.InputStream object. The data will be read * from the stream as needed until end-of-file is reached. * *

* 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 * @exception SQLException * if a database access error occurs */ public void setBinaryStream(int parameterIndex, java.io.InputStream x, int length) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setBinaryStream(parameterIndex, x, length); } /** * Clears the current parameter values immediately. *

* 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 clearParameters. * * @exception SQLException * if a database access error occurs */ public void clearParameters() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.clearParameters(); } // ---------------------------------------------------------------------- // Advanced features: /** *

* Sets the value of the designated parameter with the given object. The * second argument must be an object type; for integral values, the * java.lang equivalent objects should be used. * *

* The given Java object will be converted to the given targetSqlType before * being sent to the database. * * If the object has a custom mapping (is of a class implementing the * interface SQLData), the JDBC driver should call the method * SQLData.writeSQL to write it to the SQL data stream. If, on * the other hand, the object is of a class implementing Ref, * Blob, Clob, Struct, or * Array, the driver should pass it to the database as a value * of the corresponding SQL type. * *

* 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. * @exception SQLException * if a database access error occurs * @see Types */ public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setObject(parameterIndex, x, targetSqlType, scale); } /** * Sets the value of the designated parameter with the given object. This * method is like the method 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 * @exception SQLException * if a database access error occurs */ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setObject(parameterIndex, x, targetSqlType); } /** *

* Sets the value of the designated parameter using the given object. The * second parameter must be of type Object; therefore, the * java.lang equivalent objects should be used for built-in * types. * *

* The JDBC specification specifies a standard mapping from Java * Object types to SQL types. The given argument will be * converted to the corresponding SQL type before being sent to the * database. * *

* Note that this method may be used to pass datatabase- specific abstract * data types, by using a driver-specific Java type. * * If the object is of a class implementing the interface * SQLData, the JDBC driver should call the method * SQLData.writeSQL to write it to the SQL data stream. If, on * the other hand, the object is of a class implementing Ref, * Blob, Clob, Struct, or * Array, the driver should pass it to the database as a value * of the corresponding SQL type. *

* 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 * @exception 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 { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setObject(parameterIndex, x); } /** * Executes the SQL statement in this PreparedStatement object, * which may be any kind of SQL statement. Some prepared statements return * multiple results; the execute method handles these complex * statements as well as the simpler form of statements handled by the * methods executeQuery and executeUpdate. *

* The execute method returns a boolean to * indicate the form of the first result. You must call either the method * getResultSet or getUpdateCount to retrieve the * result; you must call getMoreResults to move to any * subsequent result(s). * * @return true if the first result is a ResultSet * object; false if the first result is an update count * or there is no result * @exception SQLException * if a database access error occurs or an argument is * supplied to this method * @see Statement#execute * @see Statement#getResultSet * @see Statement#getUpdateCount * @see Statement#getMoreResults */ public boolean execute() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return this.preparedStatement.execute(); } // --------------------------JDBC 2.0----------------------------- /** * Adds a set of parameters to this PreparedStatement object's * batch of commands. * * @exception SQLException * if a database access error occurs * @see Statement#addBatch * @since 1.2 */ public void addBatch() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.addBatch(); } /** * Sets the designated parameter to the given Reader object, * which is the given number of characters long. When a very large UNICODE * value is input to a LONGVARCHAR parameter, it may be more * practical to send it via a 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. * *

* 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 java.io.Reader object that contains the * Unicode data * @param length * the number of characters in the stream * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setCharacterStream(int parameterIndex, java.io.Reader reader, int length) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setCharacterStream(parameterIndex, reader, length); } /** * Sets the designated parameter to the given * REF(<structured-type>) value. The driver converts this * to an SQL REF value when it sends it to the database. * * @param iParam * the first parameter is 1, the second is 2, ... * @param x * an SQL REF value * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setRef(int iParam, Ref x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setRef(iParam, x); } /** * Sets the designated parameter to the given Blob object. The * driver converts this to an SQL BLOB value when it sends it * to the database. * * @param iParam * the first parameter is 1, the second is 2, ... * @param x * a Blob object that maps an SQL BLOB * value * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setBlob(int iParam, Blob x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setBlob(iParam, x); } /** * Sets the designated parameter to the given Clob object. The * driver converts this to an SQL CLOB value when it sends it * to the database. * * @param iParam * the first parameter is 1, the second is 2, ... * @param x * a Clob object that maps an SQL CLOB * value * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setClob(int iParam, Clob x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setClob(iParam, x); } /** * Sets the designated parameter to the given Array object. The * driver converts this to an SQL ARRAY value when it sends it * to the database. * * @param iParam * the first parameter is 1, the second is 2, ... * @param x * an Array object that maps an SQL * ARRAY value * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setArray(int iParam, Array x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setArray(iParam, x); } /** * Retrieves a ResultSetMetaDataHttp object that contains * information about the columns of the ResultSet object that * will be returned when this PreparedStatement object is * executed. *

* Because a PreparedStatement object is precompiled, it is * possible to know about the ResultSet object that it will * return without having to execute it. Consequently, it is possible to * invoke the method getMetaData on a * PreparedStatement object rather than waiting to execute it * and then invoking the ResultSet.getMetaData method on the * ResultSet object that is returned. *

* NOTE: Using this method may be expensive for some drivers due to * the lack of underlying DBMS support. * * @return the description of a ResultSet object's columns or * null if the driver cannot return a * ResultSetMetaDataHttp object * @exception SQLException * if a database access error occurs * @since 1.2 */ public ResultSetMetaData getMetaData() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return this.preparedStatement.getMetaData(); } /** * Sets the designated parameter to the given java.sql.Date * value, using the given Calendar object. The driver uses the * Calendar object to construct an SQL DATE value, * which the driver then sends to the database. With a a * Calendar object, the driver can calculate the date taking * into account a custom timezone. If no 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 Calendar object the driver will use to * construct the date * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setDate(int parameterIndex, java.sql.Date x, Calendar cal) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setDate(parameterIndex, x, cal); } /** * Sets the designated parameter to the given java.sql.Time * value, using the given Calendar object. The driver uses the * Calendar object to construct an SQL TIME value, * which the driver then sends to the database. With a a * Calendar object, the driver can calculate the time taking * into account a custom timezone. If no 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 Calendar object the driver will use to * construct the time * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setTime(int parameterIndex, java.sql.Time x, Calendar cal) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setTime(parameterIndex, x, cal); } /** * Sets the designated parameter to the given * java.sql.Timestamp value, using the given * Calendar object. The driver uses the Calendar * object to construct an SQL TIMESTAMP value, which the driver * then sends to the database. With a Calendar object, the * driver can calculate the timestamp taking into account a custom timezone. * If no 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 Calendar object the driver will use to * construct the timestamp * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setTimestamp(parameterIndex, x, cal); } /** * Sets the designated parameter to SQL NULL. This version of * the method 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. * *

* 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. * * 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 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 * @exception SQLException * if a database access error occurs * @since 1.2 */ public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setNull(paramIndex, sqlType, typeName); } // ------------------------- JDBC 3.0 ----------------------------------- /** * Sets the designated parameter to the given java.net.URL * value. The driver converts this to an SQL DATALINK value * when it sends it to the database. * * @param parameterIndex * the first parameter is 1, the second is 2, ... * @param x * the java.net.URL object to be set * @exception SQLException * if a database access error occurs * @since 1.4 */ public void setURL(int parameterIndex, java.net.URL x) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); this.preparedStatement.setURL(parameterIndex, x); } /** * Retrieves the number, types and properties of this * PreparedStatement object's parameters. * * @return a ParameterMetaData object that contains information * about the number, types and properties of this * PreparedStatement object's parameters * @exception SQLException * if a database access error occurs * @see ParameterMetaData * @since 1.4 */ public ParameterMetaData getParameterMetaData() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return this.preparedStatement.getParameterMetaData(); } /** * @param arg0 * @return * @throws SQLException * @see java.sql.Wrapper#isWrapperFor(java.lang.Class) */ public boolean isWrapperFor(Class arg0) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return preparedStatement.isWrapperFor(arg0); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream, * long) */ public void setAsciiStream(int arg0, InputStream arg1, long arg2) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setAsciiStream(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setAsciiStream(int, java.io.InputStream) */ public void setAsciiStream(int arg0, InputStream arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setAsciiStream(arg0, arg1); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, * long) */ public void setBinaryStream(int arg0, InputStream arg1, long arg2) throws SQLException { preparedStatement.setBinaryStream(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream) */ public void setBinaryStream(int arg0, InputStream arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setBinaryStream(arg0, arg1); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream, long) */ public void setBlob(int arg0, InputStream arg1, long arg2) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setBlob(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setBlob(int, java.io.InputStream) */ public void setBlob(int arg0, InputStream arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setBlob(arg0, arg1); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, * long) */ public void setCharacterStream(int arg0, Reader arg1, long arg2) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setCharacterStream(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader) */ public void setCharacterStream(int arg0, Reader arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setCharacterStream(arg0, arg1); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setClob(int, java.io.Reader, long) */ public void setClob(int arg0, Reader arg1, long arg2) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setClob(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setClob(int, java.io.Reader) */ public void setClob(int arg0, Reader arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setClob(arg0, arg1); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader, * long) */ public void setNCharacterStream(int arg0, Reader arg1, long arg2) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setNCharacterStream(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setNCharacterStream(int, java.io.Reader) */ public void setNCharacterStream(int arg0, Reader arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setNCharacterStream(arg0, arg1); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setNClob(int, java.sql.NClob) */ public void setNClob(int arg0, NClob arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setNClob(arg0, arg1); } /** * @param arg0 * @param arg1 * @param arg2 * @throws SQLException * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader, long) */ public void setNClob(int arg0, Reader arg1, long arg2) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setNClob(arg0, arg1, arg2); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setNClob(int, java.io.Reader) */ public void setNClob(int arg0, Reader arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setNClob(arg0, arg1); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setNString(int, java.lang.String) */ public void setNString(int arg0, String arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setNString(arg0, arg1); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setRowId(int, java.sql.RowId) */ public void setRowId(int arg0, RowId arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setRowId(arg0, arg1); } /** * @param arg0 * @param arg1 * @throws SQLException * @see java.sql.PreparedStatement#setSQLXML(int, java.sql.SQLXML) */ public void setSQLXML(int arg0, SQLXML arg1) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); preparedStatement.setSQLXML(arg0, arg1); } /** * @param * @param arg0 * @return * @throws SQLException * @see java.sql.Wrapper#unwrap(java.lang.Class) */ public T unwrap(Class arg0) throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return preparedStatement.unwrap(arg0); } /////////////////////////////////////////////////////////// // JAVA 7 METHOD EMULATION // /////////////////////////////////////////////////////////// //@Override do not not override for Java 6 compatibility public ResultSet executeQuery() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return null; } //@Override do not not override for Java 6 compatibility public int executeUpdate() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return 0; } //@Override do not not override for Java 6 compatibility public void closeOnCompletion() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); } //@Override do not not override for Java 6 compatibility public boolean isCloseOnCompletion() throws SQLException { String methodName = new Object() { }.getClass().getEnclosingMethod().getName(); verifyCallAuthorization(methodName); return false; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy