Merge pull request #23780 from eclipse-ee4j/jdbc_cleanup
Small amount of cleanup for JDBC code
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceObjectBuilder.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceObjectBuilder.java
index 72777e1..a6fb3e9 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceObjectBuilder.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceObjectBuilder.java
@@ -16,57 +16,48 @@
package com.sun.gjc.common;
-import java.lang.reflect.Method;
-import java.util.*;
+import static java.util.logging.Level.FINEST;
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Vector;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.glassfish.internal.api.ClassLoaderHierarchy;
+import org.glassfish.internal.api.Globals;
+
+import com.sun.enterprise.util.i18n.StringManager;
import com.sun.gjc.util.MethodExecutor;
+import com.sun.logging.LogDomains;
import jakarta.resource.ResourceException;
-import com.sun.logging.*;
-
-import java.util.logging.Logger;
-import java.util.logging.Level;
-
-import com.sun.enterprise.util.i18n.StringManager;
-import org.glassfish.internal.api.Globals;
-import org.glassfish.internal.api.ClassLoaderHierarchy;
-
/**
- * Utility class, which would create necessary Datasource object according to the
- * specification.
+ * Utility class, which would create necessary Datasource object according to
+ * the specification.
*
* @author Binod P.G
* @version 1.0, 02/07/23
* @see com.sun.gjc.common.DataSourceSpec
* @see com.sun.gjc.util.MethodExcecutor
*/
-public class DataSourceObjectBuilder implements java.io.Serializable {
+public class DataSourceObjectBuilder implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ private static Logger _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
+ private static final StringManager sm = StringManager.getManager(DataSourceObjectBuilder.class);
+
+ private static boolean jdbc40 = detectJDBC40();
+ private static boolean jdbc41 = detectJDBC41();
private DataSourceSpec spec;
-
- private Hashtable driverProperties = null;
-
- private MethodExecutor executor = null;
-
- private static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- }
-
- private static boolean jdbc40;
- private static boolean jdbc41;
-
- static {
- jdbc40 = detectJDBC40();
- jdbc41 = detectJDBC41();
- }
-
- private boolean debug = false;
-
- private static final StringManager sm = StringManager.getManager(
- DataSourceObjectBuilder.class);
+ private Hashtable driverProperties;
+ private MethodExecutor executor;
/**
* Construct a DataSource Object from the spec.
@@ -82,8 +73,8 @@
* Construct the DataSource Object from the spec.
*
* @return Object constructed using the DataSourceSpec.
- * @throws <code>ResourceException</code> if the class is not found or some issue in executing
- * some method.
+ * @throws <code>ResourceException</code> if the class is not found or some
+ * issue in executing some method.
*/
public Object constructDataSourceObject() throws ResourceException {
driverProperties = parseDriverProperties(spec, true);
@@ -91,8 +82,8 @@
Method[] methods = dataSourceObject.getClass().getMethods();
for (int i = 0; i < methods.length; i++) {
String methodName = methods[i].getName();
- //Check for driver properties first since some jdbc properties
- //may be supported in form of driver properties
+ // Check for driver properties first since some jdbc properties
+ // may be supported in form of driver properties
if (driverProperties.containsKey(methodName.toUpperCase(Locale.getDefault()))) {
Vector values = (Vector) driverProperties.get(methodName.toUpperCase(Locale.getDefault()));
executor.runMethod(methods[i], dataSourceObject, values);
@@ -118,7 +109,8 @@
executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.DESCRIPTION), methods[i], dataSourceObject);
} else if (methodName.equalsIgnoreCase("setNetworkProtocol")) {
- executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.NETWORKPROTOCOL), methods[i], dataSourceObject);
+ executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.NETWORKPROTOCOL), methods[i],
+ dataSourceObject);
} else if (methodName.equalsIgnoreCase("setPortNumber")) {
executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.PORTNUMBER), methods[i], dataSourceObject);
@@ -133,7 +125,8 @@
executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.MAXSTATEMENTS), methods[i], dataSourceObject);
} else if (methodName.equalsIgnoreCase("setInitialPoolSize")) {
- executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.INITIALPOOLSIZE), methods[i], dataSourceObject);
+ executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.INITIALPOOLSIZE), methods[i],
+ dataSourceObject);
} else if (methodName.equalsIgnoreCase("setMinPoolSize")) {
executor.runJavaBeanMethod(spec.getDetail(DataSourceSpec.MINPOOLSIZE), methods[i], dataSourceObject);
@@ -153,42 +146,45 @@
}
/**
- * Get the extra driver properties from the DataSourceSpec object and
- * parse them to a set of methodName and parameters. Prepare a hashtable
- * containing these details and return.
+ * Get the extra driver properties from the DataSourceSpec object and parse them
+ * to a set of methodName and parameters. Prepare a hashtable containing these
+ * details and return.
*
* @param spec <code> DataSourceSpec </code> object.
* @return Hashtable containing method names and parameters,
- * @throws ResourceException If delimiter is not provided and property string
- * is not null.
+ * @throws ResourceException If delimiter is not provided and property string is
+ * not null.
*/
- public Hashtable parseDriverProperties(DataSourceSpec spec, boolean returnUpperCase)
- throws ResourceException {
+ public Hashtable parseDriverProperties(DataSourceSpec spec, boolean returnUpperCase) throws ResourceException {
String delim = spec.getDetail(DataSourceSpec.DELIMITER);
String escape = spec.getDetail(DataSourceSpec.ESCAPECHARACTER);
String prop = spec.getDetail(DataSourceSpec.DRIVERPROPERTIES);
if (prop == null || prop.trim().equals("")) {
return new Hashtable();
- } else if (delim == null || delim.equals("")) {
- String msg = sm.getString("dsob.delim_not_specified");
- throw new ResourceException(msg);
- }else if( escape == null || escape.equals("")){
- String msg = sm.getString("dsob.escape_char_not_specified");
- throw new ResourceException(msg);
}
- return parseDriverProperties(prop,escape, delim, returnUpperCase);
+
+ if (delim == null || delim.equals("")) {
+ throw new ResourceException(sm.getString("dsob.delim_not_specified"));
+ }
+
+ if (escape == null || escape.equals("")) {
+ throw new ResourceException(sm.getString("dsob.escape_char_not_specified"));
+ }
+
+ return parseDriverProperties(prop, escape, delim, returnUpperCase);
}
/**
- * parse the driver properties and re-generate name value pairs with unescaped values.
+ * parse the driver properties and re-generate name value pairs with unescaped
+ * values.
+ *
* @param values driverProperties
* @param escape escape character
* @param delimiter delimiter
* @return Hashtable
*/
- public Hashtable parseDriverProperties(String values, String escape,
- String delimiter, boolean returnUpperCase){
+ public Hashtable parseDriverProperties(String values, String escape, String delimiter, boolean returnUpperCase) {
Hashtable result = new Hashtable();
String parsedValue = "";
String name = "";
@@ -199,15 +195,15 @@
if (values.charAt(0) == delimiterChar) {
if (values.length() > 1 && values.charAt(1) == delimiterChar) {
if (values.length() > 2 && values.charAt(2) == delimiterChar) {
- //Check for first property that does not have a value
- //There is no value specified for this property.
- //Store the name or it will be lost
+ // Check for first property that does not have a value
+ // There is no value specified for this property.
+ // Store the name or it will be lost
if (returnUpperCase) {
name = parsedValue.toUpperCase(Locale.getDefault());
} else {
name = parsedValue;
}
- //no value specified for value
+ // no value specified for value
parsedValue = "";
}
value = parsedValue;
@@ -245,14 +241,15 @@
* Creates a Datasource object according to the spec.
*
* @return Initial DataSource Object instance.
- * @throws <code>ResourceException</code> If class name is wrong or classpath is not set
- * properly.
+ * @throws <code>ResourceException</code> If class name is wrong or classpath is
+ * not set properly.
*/
private Object getDataSourceObject() throws ResourceException {
String className = spec.getDetail(DataSourceSpec.CLASSNAME);
+
try {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
- Class dataSourceClass;
+ Class<?> dataSourceClass;
try {
dataSourceClass = Class.forName(className, true, cl);
} catch (ClassNotFoundException cnfe) {
@@ -260,20 +257,17 @@
cl = Globals.get(ClassLoaderHierarchy.class).getCommonClassLoader();
dataSourceClass = Class.forName(className, true, cl);
}
- Object dataSourceObject = dataSourceClass.newInstance();
- return dataSourceObject;
+
+ return dataSourceClass.getDeclaredConstructor().newInstance();
} catch (ClassNotFoundException cnfe) {
_logger.log(Level.SEVERE, "jdbc.exc_cnfe_ds", cnfe);
- String msg = sm.getString("dsob.class_not_found", className);
- throw new ResourceException(msg);
- } catch (InstantiationException ce) {
+ throw new ResourceException(sm.getString("dsob.class_not_found", className), cnfe);
+ } catch (InstantiationException | NoSuchMethodException | InvocationTargetException ce) {
_logger.log(Level.SEVERE, "jdbc.exc_inst", className);
- String msg = sm.getString("dsob.error_instantiating", className);
- throw new ResourceException(msg);
+ throw new ResourceException(sm.getString("dsob.error_instantiating", className), ce);
} catch (IllegalAccessException ce) {
_logger.log(Level.SEVERE, "jdbc.exc_acc_inst", className);
- String msg = sm.getString("dsob.access_error", className);
- throw new ResourceException(msg);
+ throw new ResourceException(sm.getString("dsob.access_error", className), ce);
}
}
@@ -296,11 +290,9 @@
Class.forName("java.sql.Wrapper");
jdbc40 = true;
} catch (ClassNotFoundException cnfe) {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST,
- "could not find Wrapper(available in jdbc-40), jdk supports only jdbc-30");
- }
+ _logger.log(FINEST, "could not find Wrapper(available in jdbc-40), jdk supports only jdbc-30");
}
+
return jdbc40;
}
@@ -315,12 +307,10 @@
Class.forName("java.sql.PseudoColumnUsage");
jdbc41 = true;
} catch (ClassNotFoundException cnfe) {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST,
- "could not find PseudoColumnUsage(enum available in jdbc-41)," +
- " jdk supports jdbc-40 or lesser");
- }
+ _logger.log(FINEST, "could not find PseudoColumnUsage(enum available in jdbc-41),"
+ + " jdk supports jdbc-40 or lesser");
}
+
return jdbc41;
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceSpec.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceSpec.java
index 3c75710..34aec58 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceSpec.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/common/DataSourceSpec.java
@@ -16,6 +16,7 @@
package com.sun.gjc.common;
+import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
/**
@@ -25,7 +26,9 @@
* @author Binod P.G
* @version 1.0, 02/07/23
*/
-public class DataSourceSpec implements java.io.Serializable {
+public class DataSourceSpec implements Serializable {
+
+ private static final long serialVersionUID = 1L;
public static final int USERNAME = 1;
public static final int PASSWORD = 2;
@@ -53,7 +56,6 @@
public static final int DATASOURCE = 23;
public static final int CONNECTIONPOOLDATASOURCE = 24;
- //GJCINT
public static final int CONNECTIONVALIDATIONREQUIRED = 25;
public static final int VALIDATIONMETHOD = 26;
public static final int VALIDATIONTABLENAME = 27;
@@ -87,7 +89,7 @@
* Set the property.
*
* @param property Property Name to be set.
- * @param value Value of property to be set.
+ * @param value Value of property to be set.
*/
public void setDetail(int property, String value) {
details.put(property, value);
@@ -102,14 +104,13 @@
public String getDetail(int property) {
if (details.containsKey(property)) {
return details.get(property);
- } else {
- return null;
}
+
+ return null;
}
/**
- * Checks whether two <code>DataSourceSpec</code> objects
- * are equal or not.
+ * Checks whether two <code>DataSourceSpec</code> objects are equal or not.
*
* @param obj Instance of <code>DataSourceSpec</code> object.
*/
@@ -117,6 +118,7 @@
if (obj instanceof DataSourceSpec) {
return this.details.equals(((DataSourceSpec) obj).details);
}
+
return false;
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcRAConstants.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcRAConstants.java
index 1282639..8538df0 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcRAConstants.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcRAConstants.java
@@ -69,17 +69,15 @@
/**
* Dotted name used in monitoring for Statement caching.
*/
- public static final String STATEMENT_CACHE_DOTTED_NAME = GLASSFISH + ":" +
- JDBCRA + ":" + STATEMENT_CACHE_PROBE + ":";
+ public static final String STATEMENT_CACHE_DOTTED_NAME = GLASSFISH + ":" + JDBCRA + ":" + STATEMENT_CACHE_PROBE
+ + ":";
/**
* Dotted name used in monitoring for Sql Tracing.
*/
- public static final String SQL_TRACING_DOTTED_NAME = GLASSFISH + ":" +
- JDBCRA + ":" + SQL_TRACING_PROBE + ":";
+ public static final String SQL_TRACING_DOTTED_NAME = GLASSFISH + ":" + JDBCRA + ":" + SQL_TRACING_PROBE + ":";
- public static final String STATEMENT_LEAK_DOTTED_NAME = GLASSFISH + ":" +
- JDBCRA + ":" + STATEMENT_LEAK_PROBE + ":";
+ public static final String STATEMENT_LEAK_DOTTED_NAME = GLASSFISH + ":" + JDBCRA + ":" + STATEMENT_LEAK_PROBE + ":";
/**
* Represents top queries to report.
@@ -89,15 +87,6 @@
/**
* List of valid method names that can be used for sql trace monitoring.
*/
- public static final List<String> validSqlTracingMethodNames =
- Collections.unmodifiableList(
- Arrays.asList(
- "nativeSQL",
- "prepareCall",
- "prepareStatement",
- "addBatch",
- "execute",
- "executeQuery",
- "executeUpdate"
- ));
+ public static final List<String> validSqlTracingMethodNames = Collections.unmodifiableList(Arrays.asList(
+ "nativeSQL", "prepareCall", "prepareStatement", "addBatch", "execute", "executeQuery", "executeUpdate"));
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcStatsProvider.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcStatsProvider.java
index 6368475..821b783 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcStatsProvider.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/monitoring/JdbcStatsProvider.java
@@ -16,8 +16,6 @@
package com.sun.gjc.monitoring;
-import com.sun.gjc.util.SQLTrace;
-import com.sun.gjc.util.SQLTraceCache;
import org.glassfish.external.probe.provider.annotations.ProbeListener;
import org.glassfish.external.probe.provider.annotations.ProbeParam;
import org.glassfish.external.statistics.CountStatistic;
@@ -31,6 +29,9 @@
import org.glassfish.gmbal.ManagedObject;
import org.glassfish.resourcebase.resources.api.PoolInfo;
+import com.sun.gjc.util.SQLTrace;
+import com.sun.gjc.util.SQLTraceCache;
+
/**
* Provides the monitoring data for JDBC RA module
*
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/CPManagedConnectionFactory.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/CPManagedConnectionFactory.java
index 05f42e4..f8b2f6c 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/CPManagedConnectionFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/CPManagedConnectionFactory.java
@@ -16,20 +16,33 @@
package com.sun.gjc.spi;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.common.DataSourceSpec;
-import com.sun.gjc.util.SecurityUtils;
-import com.sun.logging.LogDomains;
+import static com.sun.gjc.util.SecurityUtils.getPasswordCredential;
+import static java.util.logging.Level.FINEST;
+import static java.util.logging.Level.SEVERE;
-import jakarta.resource.ResourceException;
-import jakarta.resource.spi.ConnectionRequestInfo;
-import jakarta.resource.spi.ResourceAllocationException;
-import jakarta.resource.spi.security.PasswordCredential;
+import java.sql.Connection;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.sql.ConnectionPoolDataSource;
+import javax.sql.DataSource;
+import javax.sql.PooledConnection;
+
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.common.DataSourceSpec;
+import com.sun.gjc.spi.base.AbstractDataSource;
+import com.sun.gjc.spi.base.ConnectionHolder;
+import com.sun.logging.LogDomains;
+
+import jakarta.resource.ResourceException;
import jakarta.resource.spi.ConnectionDefinition;
+import jakarta.resource.spi.ConnectionRequestInfo;
+import jakarta.resource.spi.ManagedConnection;
+import jakarta.resource.spi.ResourceAllocationException;
+import jakarta.resource.spi.security.PasswordCredential;
/**
@@ -39,20 +52,17 @@
* @version 1.0, 02/07/30
*/
@ConnectionDefinition(
- connectionFactory = javax.sql.DataSource.class,
- connectionFactoryImpl = com.sun.gjc.spi.base.AbstractDataSource.class,
- connection = java.sql.Connection.class,
- connectionImpl = com.sun.gjc.spi.base.ConnectionHolder.class
+ connectionFactory = DataSource.class,
+ connectionFactoryImpl = AbstractDataSource.class,
+ connection = Connection.class,
+ connectionImpl = ConnectionHolder.class
)
public class CPManagedConnectionFactory extends ManagedConnectionFactoryImpl {
- private transient javax.sql.ConnectionPoolDataSource cpDataSourceObj;
+ private static Logger _logger = LogDomains.getLogger(CPManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
- private static Logger _logger;
+ private transient ConnectionPoolDataSource connectionPoolDataSource;
- static {
- _logger = LogDomains.getLogger(CPManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
- }
/**
* Returns the underlying datasource
@@ -60,119 +70,86 @@
* @return DataSource of jdbc vendor
* @throws ResourceException
*/
- public javax.sql.ConnectionPoolDataSource getDataSource() throws ResourceException {
- if (cpDataSourceObj == null) {
+ public ConnectionPoolDataSource getDataSource() throws ResourceException {
+ if (connectionPoolDataSource == null) {
try {
- cpDataSourceObj = (javax.sql.ConnectionPoolDataSource) super.getDataSource();
+ connectionPoolDataSource = (ConnectionPoolDataSource) super.getDataSource();
} catch (ClassCastException cce) {
- _logger.log(Level.SEVERE, "jdbc.exc_cce_CP", cce);
- throw new ResourceException(cce.getMessage());
+ _logger.log(SEVERE, "jdbc.exc_cce_CP", cce);
+ throw new ResourceException(cce.getMessage(), cce);
}
}
- return cpDataSourceObj;
+
+ return connectionPoolDataSource;
}
/**
- * Creates a new physical connection to the underlying EIS resource
- * manager.
+ * Creates a new physical connection to the underlying EIS resource manager.
*
- * @param subject <code>Subject</code> instance passed by the application server
+ * @param subject <code>Subject</code> instance passed by the application server
* @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created
- * as a result of the invocation <code>getConnection(user, password)</code>
- * on the <code>DataSource</code> object
+ * as a result of the invocation <code>getConnection(user, password)</code> on
+ * the <code>DataSource</code> object
+ *
* @return <code>ManagedConnection</code> object created
- * @throws ResourceException if there is an error in instantiating the
- * <code>DataSource</code> object used for the
- * creation of the <code>ManagedConnection</code> object
- * @throws SecurityException if there ino <code>PasswordCredential</code> object
- * satisfying this request
+ *
+ * @throws ResourceException if there is an error in instantiating the
+ * <code>DataSource</code> object used for the creation of the
+ * <code>ManagedConnection</code> object
+ * @throws SecurityException if there ino <code>PasswordCredential</code> object
+ * satisfying this request
* @throws ResourceAllocationException if there is an error in allocating the
- * physical connection
+ * physical connection
*/
- public jakarta.resource.spi.ManagedConnection createManagedConnection(javax.security.auth.Subject subject,
- ConnectionRequestInfo cxRequestInfo) throws ResourceException {
+ public ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException {
logFine("In createManagedConnection");
- PasswordCredential pc = SecurityUtils.getPasswordCredential(this, subject, cxRequestInfo);
- javax.sql.ConnectionPoolDataSource dataSource = getDataSource();
+ PasswordCredential passwordCredential = getPasswordCredential(this, subject, cxRequestInfo);
- javax.sql.PooledConnection cpConn = null;
- ManagedConnectionImpl mc = null;
+ ConnectionPoolDataSource dataSource = getDataSource();
+
+ PooledConnection pooledConnection = null;
+ ManagedConnectionImpl managedConnectionImpl = null;
try {
- /* For the case where the user/passwd of the connection pool is
- * equal to the PasswordCredential for the connection request
- * get a connection from this pool directly.
- * for all other conditions go create a new connection
- */
- if (isEqual(pc, getUser(), getPassword())) {
- cpConn = dataSource.getPooledConnection();
+ /*
+ * For the case where the user/passwd of the connection pool is equal to the
+ * PasswordCredential for the connection request get a connection from this pool
+ * directly. for all other conditions go create a new connection
+ */
+ if (isEqual(passwordCredential, getUser(), getPassword())) {
+ pooledConnection = dataSource.getPooledConnection();
} else {
- cpConn = dataSource.getPooledConnection(pc.getUserName(),
- new String(pc.getPassword()));
+ pooledConnection = dataSource.getPooledConnection(passwordCredential.getUserName(), new String(passwordCredential.getPassword()));
}
- } catch (java.sql.SQLException sqle) {
- //_logger.log(Level.SEVERE, "jdbc.exc_create_ds_conn",sqle);
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.exc_create_ds_conn", sqle);
- }
- StringManager sm =
- StringManager.getManager(DataSourceObjectBuilder.class);
- String msg = sm.getString("jdbc.cannot_allocate_connection", sqle.getMessage());
- ResourceAllocationException rae = new ResourceAllocationException(
- msg, sqle);
- throw rae;
+ } catch (SQLException sqle) {
+ _logger.log(Level.FINE, "jdbc.exc_create_ds_conn", sqle);
+
+ throw new ResourceAllocationException(
+ StringManager.getManager(DataSourceObjectBuilder.class).getString("jdbc.cannot_allocate_connection", sqle.getMessage()),
+ sqle);
}
try {
+ managedConnectionImpl = constructManagedConnection(pooledConnection, null, passwordCredential, this);
+ managedConnectionImpl.initializeConnectionType(ManagedConnectionImpl.ISPOOLEDCONNECTION);
- mc = constructManagedConnection(cpConn, null, pc, this);
-
- mc.initializeConnectionType(ManagedConnectionImpl.ISPOOLEDCONNECTION);
-
- //GJCINT
- validateAndSetIsolation(mc);
+ validateAndSetIsolation(managedConnectionImpl);
} finally {
- if (mc == null) {
- if (cpConn != null) {
+ if (managedConnectionImpl == null) {
+ if (pooledConnection != null) {
try {
- cpConn.close();
+ pooledConnection.close();
} catch (SQLException e) {
- _logger.log(Level.FINEST, "Exception while closing connection : createManagedConnection" + cpConn);
+ _logger.log(FINEST,
+ "Exception while closing connection : createManagedConnection" + pooledConnection);
}
}
}
}
- return mc;
- }
- /**
- * Check if this <code>ManagedConnectionFactory</code> is equal to
- * another <code>ManagedConnectionFactory</code>.
- *
- * @param other <code>ManagedConnectionFactory</code> object for checking equality with
- * @return true if the property sets of both the
- * <code>ManagedConnectionFactory</code> objects are the same
- * false otherwise
- */
- public boolean equals(Object other) {
- logFine("In equals");
- /**
- * The check below means that two ManagedConnectionFactory objects are equal
- * if and only if their properties are the same.
- */
- if (other instanceof com.sun.gjc.spi.CPManagedConnectionFactory) {
- com.sun.gjc.spi.CPManagedConnectionFactory otherMCF =
- (com.sun.gjc.spi.CPManagedConnectionFactory) other;
- return this.spec.equals(otherMCF.spec);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return 31 * 7 + (spec.hashCode());
+ return managedConnectionImpl;
}
/**
@@ -294,4 +271,33 @@
public String getPropertyCycle() {
return spec.getDetail(DataSourceSpec.PROPERTYCYCLE);
}
+
+ /**
+ * Check if this <code>ManagedConnectionFactory</code> is equal to another
+ * <code>ManagedConnectionFactory</code>.
+ *
+ * @param other <code>ManagedConnectionFactory</code> object for checking
+ * equality with
+ * @return true if the property sets of both the
+ * <code>ManagedConnectionFactory</code> objects are the same false otherwise
+ */
+ public boolean equals(Object other) {
+ logFine("In equals");
+
+ /**
+ * The check below means that two ManagedConnectionFactory objects are equal if
+ * and only if their properties are the same.
+ */
+ if (other instanceof CPManagedConnectionFactory) {
+ CPManagedConnectionFactory otherMCF = (CPManagedConnectionFactory) other;
+ return this.spec.equals(otherMCF.spec);
+ }
+
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return 31 * 7 + (spec.hashCode());
+ }
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionManagerImplementation.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionManagerImplementation.java
index 6bef1fc..bd7ddca 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionManagerImplementation.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionManagerImplementation.java
@@ -17,8 +17,8 @@
package com.sun.gjc.spi;
import jakarta.resource.ResourceException;
+import jakarta.resource.spi.ConnectionManager;
import jakarta.resource.spi.ConnectionRequestInfo;
-import jakarta.resource.spi.ManagedConnection;
import jakarta.resource.spi.ManagedConnectionFactory;
/**
@@ -27,25 +27,26 @@
* @author Binod P.G
* @version 1.0, 02/07/31
*/
-public class ConnectionManagerImplementation implements jakarta.resource.spi.ConnectionManager {
+public class ConnectionManagerImplementation implements ConnectionManager {
+
+ private static final long serialVersionUID = 1L;
/**
- * Returns a <code>Connection </code> object to the <code>ConnectionFactory</code>
+ * Returns a <code>Connection </code> object to the
+ * <code>ConnectionFactory</code>
*
- * @param mcf <code>ManagedConnectionFactory</code> object.
- * @param info <code>ConnectionRequestInfo</code> object.
+ * @param managedConnectionFactory <code>ManagedConnectionFactory</code> object.
+ * @param connectionRequestInfo <code>ConnectionRequestInfo</code> object.
* @return A <code>Connection</code> Object.
* @throws ResourceException In case of an error in getting the <code>Connection</code>.
*/
- public Object allocateConnection(ManagedConnectionFactory mcf,
- ConnectionRequestInfo info)
- throws ResourceException {
- ManagedConnection mc = mcf.createManagedConnection(null, info);
- return mc.getConnection(null, info);
+ public Object allocateConnection(ManagedConnectionFactory managedConnectionFactory, ConnectionRequestInfo connectionRequestInfo) throws ResourceException {
+ return managedConnectionFactory.createManagedConnection(null, connectionRequestInfo)
+ .getConnection(null, connectionRequestInfo);
}
/*
- * This class could effectively implement Connection pooling also.
- * Could be done for FCS.
- */
+ * This class could effectively implement Connection pooling also. Could be done
+ * for FCS.
+ */
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionRequestInfoImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionRequestInfoImpl.java
index 3e9fefd..385cdbf 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionRequestInfoImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ConnectionRequestInfoImpl.java
@@ -18,13 +18,15 @@
import java.util.Arrays;
+import jakarta.resource.spi.ConnectionRequestInfo;
+
/**
* ConnectionRequestInfo implementation for Generic JDBC Connector.
*
* @author Binod P.G
* @version 1.0, 02/07/31
*/
-public class ConnectionRequestInfoImpl implements jakarta.resource.spi.ConnectionRequestInfo {
+public class ConnectionRequestInfoImpl implements ConnectionRequestInfo {
private String user;
private char[] password;
@@ -32,7 +34,7 @@
/**
* Constructs a new <code>ConnectionRequestInfoImpl</code> object
*
- * @param user User Name.
+ * @param user User Name.
* @param password Password
*/
public ConnectionRequestInfoImpl(String user, char[] password) {
@@ -64,14 +66,16 @@
* @return True, if they are equal and false otherwise.
*/
public boolean equals(Object obj) {
- if (obj == null) return false;
- if (obj instanceof ConnectionRequestInfoImpl) {
- ConnectionRequestInfoImpl other = (ConnectionRequestInfoImpl) obj;
- return (isEqual(this.user, other.user) &&
- Arrays.equals(this.password, other.password));
- } else {
+ if (obj == null) {
return false;
}
+
+ if (obj instanceof ConnectionRequestInfoImpl) {
+ ConnectionRequestInfoImpl other = (ConnectionRequestInfoImpl) obj;
+ return (isEqual(this.user, other.user) && Arrays.equals(this.password, other.password));
+ }
+
+ return false;
}
/**
@@ -93,9 +97,9 @@
private boolean isEqual(Object o1, Object o2) {
if (o1 == null) {
return (o2 == null);
- } else {
- return o1.equals(o2);
}
+
+ return o1.equals(o2);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DMManagedConnectionFactory.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DMManagedConnectionFactory.java
index 423a52e..ea7f356 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DMManagedConnectionFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DMManagedConnectionFactory.java
@@ -16,14 +16,12 @@
package com.sun.gjc.spi;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.common.DataSourceSpec;
-import com.sun.gjc.util.SecurityUtils;
-import com.sun.logging.LogDomains;
+import static com.sun.gjc.util.SecurityUtils.getPasswordCredential;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+import static java.util.logging.Level.SEVERE;
-import jakarta.resource.ResourceException;
-import jakarta.resource.spi.ConnectionRequestInfo;
-import jakarta.resource.spi.security.PasswordCredential;
+import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Hashtable;
@@ -31,135 +29,141 @@
import java.util.Properties;
import java.util.Set;
import java.util.Vector;
-import java.util.logging.Level;
import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.sql.DataSource;
+
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.common.DataSourceSpec;
+import com.sun.gjc.spi.base.AbstractDataSource;
+import com.sun.gjc.spi.base.ConnectionHolder;
+import com.sun.logging.LogDomains;
+
+import jakarta.resource.ResourceException;
import jakarta.resource.spi.ConfigProperty;
import jakarta.resource.spi.ConnectionDefinition;
+import jakarta.resource.spi.ConnectionRequestInfo;
+import jakarta.resource.spi.ManagedConnection;
+import jakarta.resource.spi.ResourceAllocationException;
+import jakarta.resource.spi.security.PasswordCredential;
/**
- * Driver Manager <code>ManagedConnectionFactory</code> implementation for Generic JDBC Connector.
+ * Driver Manager <code>ManagedConnectionFactory</code> implementation for
+ * Generic JDBC Connector.
*
* @author Evani Sai Surya Kiran
* @version 1.0, 02/07/31
*/
-@ConnectionDefinition(
- connectionFactory = javax.sql.DataSource.class,
- connectionFactoryImpl = com.sun.gjc.spi.base.AbstractDataSource.class,
- connection = java.sql.Connection.class,
- connectionImpl = com.sun.gjc.spi.base.ConnectionHolder.class
-)
+@ConnectionDefinition(connectionFactory = DataSource.class, connectionFactoryImpl = AbstractDataSource.class, connection = Connection.class, connectionImpl = ConnectionHolder.class)
public class DMManagedConnectionFactory extends ManagedConnectionFactoryImpl {
+ private static Logger _logger = LogDomains.getLogger(DMManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
+ private boolean debug = _logger.isLoggable(FINE);
+
Properties props;
- private static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(DMManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
- }
-
- private boolean debug = _logger.isLoggable(Level.FINE);
-
/**
- * Creates a new physical connection to the underlying EIS resource
- * manager.
+ * Creates a new physical connection to the underlying EIS resource manager.
*
- * @param subject <code>Subject</code> instance passed by the application server
+ * @param subject <code>Subject</code> instance passed by the application server
* @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created
- * as a result of the invocation <code>getConnection(user, password)</code>
- * on the <code>DataSource</code> object
+ * as a result of the invocation <code>getConnection(user, password)</code> on
+ * the <code>DataSource</code> object
+ *
* @return <code>ManagedConnection</code> object created
+ *
* @throws ResourceException if there is an error in instantiating the
- * <code>DataSource</code> object used for the
- * creation of the <code>ManagedConnection</code> object
+ * <code>DataSource</code> object used for the creation of the
+ * <code>ManagedConnection</code> object
* @throws SecurityException if there ino <code>PasswordCredential</code> object
- * satisfying this request
+ * satisfying this request
*/
- public jakarta.resource.spi.ManagedConnection createManagedConnection(javax.security.auth.Subject subject,
- ConnectionRequestInfo cxRequestInfo) throws ResourceException {
+ public ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException {
logFine("In createManagedConnection");
- if (dsObjBuilder == null) {
- dsObjBuilder = new DataSourceObjectBuilder(spec);
+
+ if (dataSourceObjectBuilder == null) {
+ dataSourceObjectBuilder = new DataSourceObjectBuilder(spec);
}
- PasswordCredential pc = SecurityUtils.getPasswordCredential(this, subject, cxRequestInfo);
+
+ PasswordCredential passwordCredential = getPasswordCredential(this, subject, cxRequestInfo);
try {
Class.forName(spec.getDetail(DataSourceSpec.CLASSNAME));
} catch (ClassNotFoundException cnfe) {
- _logger.log(Level.SEVERE, "jdbc.exc_cnfe", cnfe);
+ _logger.log(SEVERE, "jdbc.exc_cnfe", cnfe);
throw new ResourceException("The driver could not be loaded: " + spec.getDetail(DataSourceSpec.CLASSNAME));
}
- java.sql.Connection dsConn = null;
- ManagedConnectionImpl mc = null;
+ Connection connection = null;
+ ManagedConnectionImpl managedConnectionImpl = null;
Properties driverProps = new Properties();
- //Will return a set of properties that would have setURL and <url> as objects
- //Get a set of normal case properties
- Hashtable properties = dsObjBuilder.parseDriverProperties(spec, false);
- Set<Map.Entry<String,Vector>> entries =
- (Set<Map.Entry<String, Vector>>) properties.entrySet();
- for(Map.Entry<String, Vector> entry : entries) {
+
+ // Will return a set of properties that would have setURL and <url> as objects
+ // Get a set of normal case properties
+ Hashtable properties = dataSourceObjectBuilder.parseDriverProperties(spec, false);
+ Set<Map.Entry<String, Vector>> entries = properties.entrySet();
+ for (Map.Entry<String, Vector> entry : entries) {
String value = "";
- String key = (String) entry.getKey();
- Vector values = (Vector) entry.getValue();
- if(!values.isEmpty() && values.size() == 1) {
+ String key = entry.getKey();
+ Vector values = entry.getValue();
+ if (!values.isEmpty() && values.size() == 1) {
value = (String) values.firstElement();
- } else if(values.size() > 1) {
+ } else if (values.size() > 1) {
logFine("More than one value for key : " + key);
}
+
String prop = getParsedKey(key);
driverProps.put(prop, value);
- if(prop.equalsIgnoreCase("URL")) {
- if(spec.getDetail(DataSourceSpec.URL) == null) {
+ if (prop.equalsIgnoreCase("URL")) {
+ if (spec.getDetail(DataSourceSpec.URL) == null) {
setConnectionURL(value);
}
}
}
+
try {
if (cxRequestInfo != null) {
- driverProps.setProperty("user", pc.getUserName());
- driverProps.setProperty("password", new String(pc.getPassword()));
+ driverProps.setProperty("user", passwordCredential.getUserName());
+ driverProps.setProperty("password", new String(passwordCredential.getPassword()));
} else {
String user = spec.getDetail(DataSourceSpec.USERNAME);
String password = spec.getDetail(DataSourceSpec.PASSWORD);
- if(user != null) {
+ if (user != null) {
driverProps.setProperty("user", user);
}
- if(password != null) {
+ if (password != null) {
driverProps.setProperty("password", password);
}
}
- dsConn = DriverManager.getConnection(spec.getDetail(DataSourceSpec.URL), driverProps);
+ connection = DriverManager.getConnection(spec.getDetail(DataSourceSpec.URL), driverProps);
- } catch (java.sql.SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_create_mc", sqle);
- throw new jakarta.resource.spi.ResourceAllocationException("The connection could not be allocated: " +
- sqle.getMessage());
+ } catch (SQLException sqle) {
+ _logger.log(SEVERE, "jdbc.exc_create_mc", sqle);
+ throw new ResourceAllocationException("The connection could not be allocated: " + sqle.getMessage());
}
try {
-
- mc = constructManagedConnection(null, dsConn, pc, this);
-
- //GJCINT
- validateAndSetIsolation(mc);
+ managedConnectionImpl = constructManagedConnection(null, connection, passwordCredential, this);
+ validateAndSetIsolation(managedConnectionImpl);
} finally {
- if (mc == null) {
+ if (managedConnectionImpl == null) {
try {
- dsConn.close();
+ connection.close();
} catch (SQLException e) {
- _logger.log(Level.FINEST, "Exception while closing connection : createManagedConnection" + dsConn);
+ _logger.log(FINEST, "Exception while closing connection : createManagedConnection" + connection, e);
}
}
}
- return mc;
+
+ return managedConnectionImpl;
}
/**
- * Parses the key and removes the "set" string at the beginning of the
- * property.
+ * Parses the key and removes the "set" string at the beginning of the property.
+ *
* @param key
* @return
*/
@@ -170,138 +174,25 @@
indexOfSet = key.indexOf("set");
} catch (NullPointerException npe) {
if (debug) {
- _logger.log(Level.FINE, "jdbc.exc_caught_ign", npe.getMessage());
+ _logger.log(FINE, "jdbc.exc_caught_ign", npe.getMessage());
}
}
if (indexOfSet == 0) {
- //Find the key String
-
+ // Find the key String
try {
parsedKey = key.substring(indexOfSet + 3, key.length()).trim();
} catch (IndexOutOfBoundsException iobe) {
if (debug) {
- _logger.log(Level.FINE, "jdbc.exc_caught_ign", iobe.getMessage());
+ _logger.log(FINE, "jdbc.exc_caught_ign", iobe.getMessage());
}
}
if (parsedKey != null && parsedKey.equals("")) {
- throw new ResourceException("Invalid driver properties string - " +
- "Key cannot be an empty string");
+ throw new ResourceException("Invalid driver properties string - " + "Key cannot be an empty string");
}
}
+
return parsedKey;
-
- }
-
- /**
- * This method checks if the properties object is null or not.
- * If the properties object is null, it creates a new Properties
- * object and inserts the default "user" and "password" key value
- * pairs. It checks if any other properties have been set or not
- * and includes the key value pairs for those properties.
- *
- * @return props <code>Properties</code> object conatining properties for getting a connection
- * @throws ResourceException if the driver properties string and delimiter are not proper
- */
- //TODO remove unused method
- /*private Properties getPropertiesObj() throws ResourceException {
- if (props != null) {
- return props;
- }
-
- props = new Properties();
- props.setProperty("user", getUser());
- props.setProperty("password", getPassword());
-
- String driverProps = spec.getDetail(DataSourceSpec.DRIVERPROPERTIES);
- String delimiter = spec.getDetail(DataSourceSpec.DELIMITER);
-
- if (driverProps != null && driverProps.trim().equals("") == false) {
- if (delimiter == null || delimiter.equals("")) {
- throw new ResourceException("Invalid driver properties string - " +
- "delimiter not properly set!!");
- }
-
- StringTokenizer st = new StringTokenizer(driverProps, delimiter);
- while (st.hasMoreTokens()) {
- String keyValuePair = null;
- try {
- keyValuePair = st.nextToken();
- } catch (NoSuchElementException nsee) {
- throw new ResourceException("Invalid driver properties string - " +
- "Key value pair not available: " + nsee.getMessage());
- }
-
- int indexOfEqualsSign = -1;
- try {
- indexOfEqualsSign = keyValuePair.indexOf("=");
- if (indexOfEqualsSign == -1) {
- throw new ResourceException("Invalid driver properties string - " +
- "Key value pair should be of the form key = value");
- }
- } catch (NullPointerException npe) {
- if (debug) {
- _logger.log(Level.FINE, "jdbc.exc_caught_ign", npe.getMessage());
- }
-
- }
-
- String key = null;
- try {
- key = keyValuePair.substring(0, indexOfEqualsSign).trim();
- } catch (IndexOutOfBoundsException iobe) {
- if (debug) {
- _logger.log(Level.FINE, "jdbc.exc_caught_ign", iobe.getMessage());
- }
- }
- if (key != null && key.equals("")) {
- throw new ResourceException("Invalid driver properties string - " +
- "Key cannot be an empty string");
- }
-
- String value = null;
- try {
- value = keyValuePair.substring(indexOfEqualsSign + 1).trim();
- } catch (IndexOutOfBoundsException iobe) {
- if (debug) {
- _logger.log(Level.FINE, "jdbc.exc_caught_ign", iobe.getMessage());
- }
- }
-
- props.setProperty(key, value);
- }
- }
-
- return props;
- } */
-
- /**
- * Check if this <code>ManagedConnectionFactory</code> is equal to
- * another <code>ManagedConnectionFactory</code>.
- *
- * @param other <code>ManagedConnectionFactory</code> object for checking equality with
- * @return true if the property sets of both the
- * <code>ManagedConnectionFactory</code> objects are the same
- * false otherwise
- */
- public boolean equals(Object other) {
- logFine("In equals");
-
- /**
- * The check below means that two ManagedConnectionFactory objects are equal
- * if and only if their properties are the same.
- */
- if (other instanceof com.sun.gjc.spi.DMManagedConnectionFactory) {
- com.sun.gjc.spi.DMManagedConnectionFactory otherMCF =
- (com.sun.gjc.spi.DMManagedConnectionFactory) other;
- return this.spec.equals(otherMCF.spec);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return 31 * 7 + (spec.hashCode());
}
/**
@@ -311,14 +202,12 @@
* @see <code>getLoginTimeOut</code>
*/
public void setLoginTimeOut(String loginTimeOut) {
- int timeOut = 0;
try {
- timeOut = Integer.parseInt(loginTimeOut);
- DriverManager.setLoginTimeout(timeOut);
+ DriverManager.setLoginTimeout(Integer.parseInt(loginTimeOut));
spec.setDetail(DataSourceSpec.LOGINTIMEOUT, loginTimeOut);
} catch (Exception e) {
if (debug) {
- _logger.log(Level.FINE, "jdbc.exc_caught_ign", e.getMessage());
+ _logger.log(FINE, "jdbc.exc_caught_ign", e.getMessage());
}
}
}
@@ -365,4 +254,33 @@
public Object getDataSource() throws ResourceException {
return null;
}
+
+ /**
+ * Check if this <code>ManagedConnectionFactory</code> is equal to another
+ * <code>ManagedConnectionFactory</code>.
+ *
+ * @param other <code>ManagedConnectionFactory</code> object for checking
+ * equality with
+ * @return true if the property sets of both the
+ * <code>ManagedConnectionFactory</code> objects are the same false otherwise
+ */
+ public boolean equals(Object other) {
+ logFine("In equals");
+
+ /**
+ * The check below means that two ManagedConnectionFactory objects are equal if
+ * and only if their properties are the same.
+ */
+ if (other instanceof DMManagedConnectionFactory) {
+ DMManagedConnectionFactory otherMCF = (DMManagedConnectionFactory) other;
+ return this.spec.equals(otherMCF.spec);
+ }
+
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return 31 * 7 + (spec.hashCode());
+ }
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DSManagedConnectionFactory.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DSManagedConnectionFactory.java
index 9bb6a24..90cc252 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DSManagedConnectionFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/DSManagedConnectionFactory.java
@@ -16,19 +16,30 @@
package com.sun.gjc.spi;
+import static com.sun.gjc.util.SecurityUtils.getPasswordCredential;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+import static java.util.logging.Level.SEVERE;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.sql.DataSource;
+
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.util.SecurityUtils;
+import com.sun.gjc.spi.base.AbstractDataSource;
+import com.sun.gjc.spi.base.ConnectionHolder;
import com.sun.logging.LogDomains;
import jakarta.resource.ResourceException;
+import jakarta.resource.spi.ConnectionDefinition;
import jakarta.resource.spi.ConnectionRequestInfo;
+import jakarta.resource.spi.ManagedConnection;
import jakarta.resource.spi.ResourceAllocationException;
import jakarta.resource.spi.security.PasswordCredential;
-import java.sql.SQLException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import jakarta.resource.spi.ConnectionDefinition;
/**
* Data Source <code>ManagedConnectionFactory</code> implementation for Generic JDBC Connector.
@@ -38,93 +49,82 @@
*/
@ConnectionDefinition(
- connectionFactory = javax.sql.DataSource.class,
- connectionFactoryImpl = com.sun.gjc.spi.base.AbstractDataSource.class,
+ connectionFactory = DataSource.class,
+ connectionFactoryImpl = AbstractDataSource.class,
connection = java.sql.Connection.class,
- connectionImpl = com.sun.gjc.spi.base.ConnectionHolder.class
+ connectionImpl = ConnectionHolder.class
)
public class DSManagedConnectionFactory extends ManagedConnectionFactoryImpl {
- private transient javax.sql.DataSource dataSourceObj;
+ private static Logger _logger = LogDomains.getLogger(DSManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
- private static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(DSManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
- }
+ private transient DataSource dataSourceObj;
/**
- * Creates a new physical connection to the underlying EIS resource
- * manager.
+ * Creates a new physical connection to the underlying EIS resource manager.
*
- * @param subject <code>Subject</code> instance passed by the application server
- * @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created
- * as a result of the invocation <code>getConnection(user, password)</code>
- * on the <code>DataSource</code> object
+ * @param subject <code>Subject</code> instance passed by the application server
+ * @param connectionRequestInfo <code>ConnectionRequestInfo</code> which may be created
+ * as a result of the invocation <code>getConnection(user, password)</code> on
+ * the <code>DataSource</code> object
+ *
* @return <code>ManagedConnection</code> object created
- * @throws ResourceException if there is an error in instantiating the
- * <code>DataSource</code> object used for the
- * creation of the <code>ManagedConnection</code> object
- * @throws SecurityException if there ino <code>PasswordCredential</code> object
- * satisfying this request
+ *
+ * @throws ResourceException if there is an error in instantiating the
+ * <code>DataSource</code> object used for the creation of the
+ * <code>ManagedConnection</code> object
+ * @throws SecurityException if there ino <code>PasswordCredential</code> object
+ * satisfying this request
* @throws ResourceAllocationException if there is an error in allocating the
- * physical connection
+ * physical connection
*/
- public jakarta.resource.spi.ManagedConnection createManagedConnection(javax.security.auth.Subject subject,
- ConnectionRequestInfo cxRequestInfo) throws ResourceException {
+ public ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo connectionRequestInfo) throws ResourceException {
logFine("In createManagedConnection");
- PasswordCredential pc = SecurityUtils.getPasswordCredential(this, subject, cxRequestInfo);
+ PasswordCredential passwordCredential = getPasswordCredential(this, subject, connectionRequestInfo);
- javax.sql.DataSource dataSource = getDataSource();
+ DataSource dataSource = getDataSource();
- java.sql.Connection dsConn = null;
- ManagedConnectionImpl mc = null;
+ Connection connection = null;
+ ManagedConnectionImpl managedConnectionImpl = null;
try {
- /* For the case where the user/passwd of the connection pool is
- * equal to the PasswordCredential for the connection request
- * get a connection from this pool directly.
- * for all other conditions go create a new connection
- */
- if (isEqual(pc, getUser(), getPassword())) {
- dsConn = dataSource.getConnection();
+ /*
+ * For the case where the user/passwd of the connection pool is equal to the
+ * PasswordCredential for the connection request get a connection from this pool
+ * directly. for all other conditions go create a new connection
+ */
+ if (isEqual(passwordCredential, getUser(), getPassword())) {
+ connection = dataSource.getConnection();
} else {
- dsConn = dataSource.getConnection(pc.getUserName(),
- new String(pc.getPassword()));
+ connection = dataSource.getConnection(passwordCredential.getUserName(), new String(passwordCredential.getPassword()));
}
- } catch (java.sql.SQLException sqle) {
- //_logger.log(Level.WARNING, "jdbc.exc_create_conn", sqle.getMessage());
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.exc_create_conn", sqle.getMessage());
- }
- StringManager localStrings =
- StringManager.getManager(DataSourceObjectBuilder.class);
- String msg = localStrings.getString("jdbc.cannot_allocate_connection"
- , sqle.getMessage());
- ResourceAllocationException rae = new ResourceAllocationException(msg);
- rae.initCause(sqle);
- throw rae;
+ } catch (SQLException sqle) {
+ _logger.log(FINE, "jdbc.exc_create_conn", sqle.getMessage());
+
+ throw new ResourceAllocationException(
+ StringManager.getManager(DataSourceObjectBuilder.class).getString("jdbc.cannot_allocate_connection", sqle.getMessage()),
+ sqle);
}
try {
- mc = constructManagedConnection(null, dsConn, pc, this);
+ managedConnectionImpl = constructManagedConnection(null, connection, passwordCredential, this);
- //GJCINT
- validateAndSetIsolation(mc);
+ validateAndSetIsolation(managedConnectionImpl);
} finally {
- if (mc == null) {
- if (dsConn != null) {
+ if (managedConnectionImpl == null) {
+ if (connection != null) {
try {
- dsConn.close();
+ connection.close();
} catch (SQLException e) {
- _logger.log(Level.FINEST, "Exception while closing connection : " +
- "createManagedConnection" + dsConn);
+ _logger.log(FINEST,
+ "Exception while closing connection : " + "createManagedConnection" + connection);
}
}
}
}
- return mc;
+
+ return managedConnectionImpl;
}
/**
@@ -133,38 +133,40 @@
* @return DataSource of jdbc vendor
* @throws ResourceException
*/
- public javax.sql.DataSource getDataSource() throws ResourceException {
+ public DataSource getDataSource() throws ResourceException {
if (dataSourceObj == null) {
try {
- dataSourceObj = (javax.sql.DataSource) super.getDataSource();
+ dataSourceObj = (DataSource) super.getDataSource();
} catch (ClassCastException cce) {
- _logger.log(Level.SEVERE, "jdbc.exc_cce", cce);
+ _logger.log(SEVERE, "jdbc.exc_cce", cce);
throw new ResourceException(cce.getMessage());
}
}
+
return dataSourceObj;
}
/**
- * Check if this <code>ManagedConnectionFactory</code> is equal to
- * another <code>ManagedConnectionFactory</code>.
+ * Check if this <code>ManagedConnectionFactory</code> is equal to another
+ * <code>ManagedConnectionFactory</code>.
*
- * @param other <code>ManagedConnectionFactory</code> object for checking equality with
- * @return true if the property sets of both the
- * <code>ManagedConnectionFactory</code> objects are the same
- * false otherwise
+ * @param other <code>ManagedConnectionFactory</code> object for checking
+ * equality with
+ * @return true if the property sets of both the
+ * <code>ManagedConnectionFactory</code> objects are the same false otherwise
*/
public boolean equals(Object other) {
logFine("In equals");
+
/**
- * The check below means that two ManagedConnectionFactory objects are equal
- * if and only if their properties are the same.
+ * The check below means that two ManagedConnectionFactory objects are equal if
+ * and only if their properties are the same.
*/
- if (other instanceof com.sun.gjc.spi.DSManagedConnectionFactory) {
- com.sun.gjc.spi.DSManagedConnectionFactory otherMCF =
- (com.sun.gjc.spi.DSManagedConnectionFactory) other;
+ if (other instanceof DSManagedConnectionFactory) {
+ DSManagedConnectionFactory otherMCF = (DSManagedConnectionFactory) other;
return this.spec.equals(otherMCF.spec);
}
+
return false;
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/JdbcObjectsFactory.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/JdbcObjectsFactory.java
index d3af802..899e581 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/JdbcObjectsFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/JdbcObjectsFactory.java
@@ -16,50 +16,62 @@
package com.sun.gjc.spi;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.spi.base.ConnectionHolder;
-import com.sun.gjc.util.SQLTraceDelegator;
-import com.sun.logging.LogDomains;
+import static java.util.logging.Level.SEVERE;
+import static java.util.logging.Level.WARNING;
import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
-import java.util.logging.Level;
import java.util.logging.Logger;
+
+import javax.sql.DataSource;
+
import org.glassfish.api.jdbc.SQLTraceRecord;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.spi.base.ConnectionHolder;
+import com.sun.gjc.util.SQLTraceDelegator;
+import com.sun.logging.LogDomains;
+
+import jakarta.resource.spi.ConnectionManager;
+import jakarta.resource.spi.ConnectionRequestInfo;
/**
* Factory to create JDBC objects
*/
public abstract class JdbcObjectsFactory implements Serializable {
- protected final static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(JdbcObjectsFactory.class, LogDomains.RSR_LOGGER);
- }
+ private static final long serialVersionUID = 1L;
+ protected final static Logger _logger = LogDomains.getLogger(JdbcObjectsFactory.class, LogDomains.RSR_LOGGER);
/**
- * Returns JDBC Objet Factory for JDBC 3.0 or JDBC 4.0 depending upon the jdbc version<br>
- * available in JDK.<br>
+ * Returns JDBC Object Factory for JDBC 3.0 or JDBC 4.0 depending upon the jdbc
+ * version available in JDK.
*
* @return JdbcObjectsFactory
*/
public static JdbcObjectsFactory getInstance() {
boolean jdbc40 = DataSourceObjectBuilder.isJDBC40();
+
JdbcObjectsFactory factory = null;
try {
if (jdbc40) {
- factory = (JdbcObjectsFactory) Class.forName("com.sun.gjc.spi.jdbc40.Jdbc40ObjectsFactory").newInstance();
+ factory = (JdbcObjectsFactory)
+ Class.forName("com.sun.gjc.spi.jdbc40.Jdbc40ObjectsFactory")
+ .getDeclaredConstructor()
+ .newInstance();
} else {
- factory = (JdbcObjectsFactory) Class.forName("com.sun.gjc.spi.jdbc30.Jdbc30ObjectsFactory").newInstance();
+ factory = (JdbcObjectsFactory)
+ Class.forName("com.sun.gjc.spi.jdbc30.Jdbc30ObjectsFactory")
+ .getDeclaredConstructor()
+ .newInstance();
}
} catch (Exception e) {
- _logger.log(Level.WARNING, "jdbc.jdbc_factory_class_load_exception", e);
+ _logger.log(WARNING, "jdbc.jdbc_factory_class_load_exception", e);
}
+
return factory;
}
@@ -67,45 +79,38 @@
* Returns a DataSource instance.
*
* @param mcfObject Managed Connection Factory
- * @param cmObject Connection Manager
+ * @param cmObject Connection Manager
* @return DataSource
*/
- public abstract javax.sql.DataSource getDataSourceInstance(ManagedConnectionFactoryImpl mcfObject,
- jakarta.resource.spi.ConnectionManager cmObject);
+ public abstract DataSource getDataSourceInstance(ManagedConnectionFactoryImpl mcfObject, ConnectionManager cmObject);
/**
* To get an instance of ConnectionHolder.<br>
* Will return a ConnectionHolder with or without wrapper<br>
*
- * @param conObject Connection
- * @param mcObject ManagedConnection
- * @param criObject Connection Request Info
+ * @param conObject Connection
+ * @param mcObject ManagedConnection
+ * @param criObject Connection Request Info
* @param statementWrapping Whether to wrap statement objects or not.
* @return ConnectionHolder
*/
- public abstract ConnectionHolder getConnection(Connection conObject,
- ManagedConnectionImpl mcObject,
- jakarta.resource.spi.ConnectionRequestInfo criObject,
- boolean statementWrapping,
- SQLTraceDelegator sqlTraceDelegator);
+ public abstract ConnectionHolder getConnection(Connection conObject, ManagedConnectionImpl mcObject,
+ ConnectionRequestInfo criObject, boolean statementWrapping,
+ SQLTraceDelegator sqlTraceDelegator);
- protected Connection getProxiedConnection(final Object conObject, Class[] connIntf,
- final SQLTraceDelegator sqlTraceDelegator) {
+ protected Connection getProxiedConnection(final Object conObject, Class[] connIntf, final SQLTraceDelegator sqlTraceDelegator) {
Connection proxiedConn = null;
try {
-
proxiedConn = (Connection) getProxyObject(conObject, connIntf, sqlTraceDelegator);
} catch (Exception ex) {
- _logger.log(Level.SEVERE, "jdbc.jdbc_proxied_connection_get_exception", ex.getMessage());
+ _logger.log(SEVERE, "jdbc.jdbc_proxied_connection_get_exception", ex.getMessage());
}
+
return proxiedConn;
}
- protected <T> T getProxyObject(final Object actualObject, Class<T>[] ifaces,
- final SQLTraceDelegator sqlTraceDelegator) throws Exception {
-
- T result;
- InvocationHandler ih = new InvocationHandler() {
+ protected <T> T getProxyObject(final Object actualObject, Class<T>[] ifaces, final SQLTraceDelegator sqlTraceDelegator) throws Exception {
+ InvocationHandler invocationHandler = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SQLTraceRecord record = new SQLTraceRecord();
@@ -116,11 +121,12 @@
record.setThreadID(Thread.currentThread().getId());
record.setTimeStamp(System.currentTimeMillis());
sqlTraceDelegator.sqlTrace(record);
+
return method.invoke(actualObject, args);
}
};
- result = (T) Proxy.newProxyInstance(actualObject.getClass().getClassLoader(), ifaces, ih);
- return result;
+
+ return (T) Proxy.newProxyInstance(actualObject.getClass().getClassLoader(), ifaces, invocationHandler);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/LocalTransactionImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/LocalTransactionImpl.java
index 7a8f77b..f3501eb 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/LocalTransactionImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/LocalTransactionImpl.java
@@ -16,13 +16,15 @@
package com.sun.gjc.spi;
+import static java.util.logging.Level.FINEST;
+
+import java.sql.SQLException;
+import java.util.logging.Logger;
import com.sun.logging.LogDomains;
import jakarta.resource.ResourceException;
import jakarta.resource.spi.LocalTransactionException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
* <code>LocalTransactionImpl</code> implementation for Generic JDBC Connector.
@@ -32,40 +34,37 @@
*/
public class LocalTransactionImpl implements jakarta.resource.spi.LocalTransaction {
- private ManagedConnectionImpl mc;
- protected final static Logger _logger;
+ protected final static Logger _logger = LogDomains.getLogger(LocalTransactionImpl.class, LogDomains.RSR_LOGGER);
- static {
- _logger = LogDomains.getLogger(LocalTransactionImpl.class, LogDomains.RSR_LOGGER);
- }
+ private ManagedConnectionImpl managedConnectionImpl;
/**
* Constructor for <code>LocalTransactionImpl</code>.
*
- * @param mc <code>ManagedConnection</code> that returns
- * this <code>LocalTransactionImpl</code> object as
- * a result of <code>getLocalTransaction</code>
+ * @param managedConnectionImpl <code>ManagedConnection</code> that returns this
+ * <code>LocalTransactionImpl</code> object as a result of
+ * <code>getLocalTransaction</code>
*/
- public LocalTransactionImpl(ManagedConnectionImpl mc) {
- this.mc = mc;
+ public LocalTransactionImpl(ManagedConnectionImpl managedConnectionImpl) {
+ this.managedConnectionImpl = managedConnectionImpl;
}
/**
* Begin a local transaction.
*
- * @throws LocalTransactionException if there is an error in changing
- * the autocommit mode of the physical
- * connection
+ * @throws LocalTransactionException if there is an error in changing the
+ * autocommit mode of the physical connection
*/
public void begin() throws ResourceException {
- //GJCINT
- mc.transactionStarted();
+ managedConnectionImpl.transactionStarted();
+
try {
- mc.getActualConnection().setAutoCommit(false);
- } catch (java.sql.SQLException sqle) {
- if(_logger.isLoggable(Level.FINEST)){
+ managedConnectionImpl.getActualConnection().setAutoCommit(false);
+ } catch (SQLException sqle) {
+ if (_logger.isLoggable(FINEST)) {
_logger.finest("Exception during begin() : " + sqle);
}
+
throw new LocalTransactionException(sqle.getMessage(), sqle);
}
}
@@ -73,44 +72,42 @@
/**
* Commit a local transaction.
*
- * @throws LocalTransactionException if there is an error in changing
- * the autocommit mode of the physical
- * connection or committing the transaction
+ * @throws LocalTransactionException if there is an error in changing the
+ * autocommit mode of the physical connection or committing the transaction
*/
public void commit() throws ResourceException {
try {
- mc.getActualConnection().commit();
- mc.getActualConnection().setAutoCommit(true);
- } catch (java.sql.SQLException sqle) {
- if(_logger.isLoggable(Level.FINEST)){
+ managedConnectionImpl.getActualConnection().commit();
+ managedConnectionImpl.getActualConnection().setAutoCommit(true);
+ } catch (SQLException sqle) {
+ if (_logger.isLoggable(FINEST)) {
_logger.finest("Exception during commit() : " + sqle);
}
+
throw new LocalTransactionException(sqle.getMessage(), sqle);
} finally {
- //GJCINT
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
}
}
/**
* Rollback a local transaction.
*
- * @throws LocalTransactionException if there is an error in changing
- * the autocommit mode of the physical
- * connection or rolling back the transaction
+ * @throws LocalTransactionException if there is an error in changing the
+ * autocommit mode of the physical connection or rolling back the transaction
*/
public void rollback() throws ResourceException {
try {
- mc.getActualConnection().rollback();
- mc.getActualConnection().setAutoCommit(true);
- } catch (java.sql.SQLException sqle) {
- if(_logger.isLoggable(Level.FINEST)){
+ managedConnectionImpl.getActualConnection().rollback();
+ managedConnectionImpl.getActualConnection().setAutoCommit(true);
+ } catch (SQLException sqle) {
+ if (_logger.isLoggable(FINEST)) {
_logger.finest("Exception during rollback() : " + sqle);
}
+
throw new LocalTransactionException(sqle.getMessage(), sqle);
} finally {
- //GJCINT
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionFactoryImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionFactoryImpl.java
index 59f307b..998a02f 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionFactoryImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionFactoryImpl.java
@@ -17,86 +17,106 @@
package com.sun.gjc.spi;
-import com.sun.appserv.connectors.internal.spi.MCFLifecycleListener;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.common.DataSourceSpec;
-import com.sun.gjc.monitoring.JdbcStatsProvider;
-import com.sun.gjc.util.SQLTraceDelegator;
-import com.sun.gjc.util.SecurityUtils;
-import com.sun.logging.LogDomains;
+import static com.sun.gjc.util.SecurityUtils.getPasswordCredential;
+import static com.sun.gjc.util.SecurityUtils.isPasswordCredentialEqual;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.SEVERE;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.io.PrintWriter;
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Timer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.sql.DataSource;
+import javax.sql.PooledConnection;
+
import org.glassfish.api.jdbc.ConnectionValidation;
import org.glassfish.api.jdbc.SQLTraceListener;
import org.glassfish.external.probe.provider.PluginPoint;
import org.glassfish.external.probe.provider.StatsProviderManager;
import org.glassfish.resourcebase.resources.api.PoolInfo;
+import com.sun.appserv.connectors.internal.spi.MCFLifecycleListener;
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.common.DataSourceSpec;
+import com.sun.gjc.monitoring.JdbcStatsProvider;
+import com.sun.gjc.util.SQLTraceDelegator;
+import com.sun.logging.LogDomains;
+
import jakarta.resource.ResourceException;
import jakarta.resource.spi.ConfigProperty;
+import jakarta.resource.spi.ConnectionManager;
import jakarta.resource.spi.ConnectionRequestInfo;
+import jakarta.resource.spi.LazyEnlistableConnectionManager;
+import jakarta.resource.spi.ManagedConnection;
+import jakarta.resource.spi.ManagedConnectionFactory;
+import jakarta.resource.spi.ResourceAdapter;
import jakarta.resource.spi.ResourceAdapterAssociation;
import jakarta.resource.spi.ResourceAllocationException;
+import jakarta.resource.spi.ValidatingManagedConnectionFactory;
import jakarta.resource.spi.security.PasswordCredential;
-import javax.sql.PooledConnection;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.sql.Connection;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
- * <code>ManagedConnectionFactory</code> implementation for Generic JDBC Connector.
- * This class is extended by the DataSource specific <code>ManagedConnection</code> factories
- * and the <code>ManagedConnectionFactory</code> for the <code>DriverManager</code>.
+ * <code>ManagedConnectionFactory</code> implementation for Generic JDBC
+ * Connector. This class is extended by the DataSource specific
+ * <code>ManagedConnection</code> factories and the
+ * <code>ManagedConnectionFactory</code> for the <code>DriverManager</code>.
*
* @author Evani Sai Surya Kiran, Aditya Gore
* @version 1.0, 02/08/03
*/
-public abstract class ManagedConnectionFactoryImpl implements jakarta.resource.spi.ManagedConnectionFactory,
- jakarta.resource.spi.ValidatingManagedConnectionFactory,
- MCFLifecycleListener, ResourceAdapterAssociation,
- java.io.Serializable, Externalizable {
+public abstract class ManagedConnectionFactoryImpl
+ implements ManagedConnectionFactory, ValidatingManagedConnectionFactory, MCFLifecycleListener,
+ ResourceAdapterAssociation, Serializable, Externalizable {
+
+ private static Logger _logger = LogDomains.getLogger(ManagedConnectionFactoryImpl.class, LogDomains.RSR_LOGGER);
+ protected static final StringManager localStrings = StringManager.getManager(DataSourceObjectBuilder.class);
protected DataSourceSpec spec = new DataSourceSpec();
- protected transient DataSourceObjectBuilder dsObjBuilder;
-
- protected java.io.PrintWriter logWriter = null;
- protected transient jakarta.resource.spi.ResourceAdapter ra = null;
-
- private static Logger _logger;
+ protected transient DataSourceObjectBuilder dataSourceObjectBuilder;
+ protected PrintWriter logWriter;
+ protected transient ResourceAdapter resourceAdapter;
protected boolean statementWrapping;
+ protected SQLTraceDelegator sqlTraceDelegator;
+ protected LazyEnlistableConnectionManager connectionManager;
+ protected boolean isLazyConnectionManager;
private JdbcObjectsFactory jdbcObjectsFactory = JdbcObjectsFactory.getInstance();
- protected SQLTraceDelegator sqlTraceDelegator;
+ private int statementCacheSize;
+ private String statementCacheType;
+ private long statementLeakTimeout;
+ private boolean statementLeakReclaim;
- static {
- _logger = LogDomains.getLogger(ManagedConnectionFactoryImpl.class, LogDomains.RSR_LOGGER);
- }
-
- protected jakarta.resource.spi.LazyEnlistableConnectionManager cm_;
- protected boolean isLazyCm_;
- private int statementCacheSize = 0;
- private String statementCacheType = null;
- private long statementLeakTimeout = 0;
- private boolean statementLeakReclaim = false;
-
- //Jdbc Stats provider that is created
- private JdbcStatsProvider jdbcStatsProvider = null;
-
- protected static final StringManager localStrings =
- StringManager.getManager(DataSourceObjectBuilder.class);
+ // Jdbc Stats provider that is created
+ private JdbcStatsProvider jdbcStatsProvider;
/**
- * Creates a Connection Factory instance. The <code>ConnectionManager</code> implementation
- * of the resource adapter is used here.
+ * Creates a Connection Factory instance. The <code>ConnectionManager</code>
+ * implementation of the resource adapter is used here.
*
- * @return Generic JDBC Connector implementation of <code>javax.sql.DataSource</code>
+ * @return Generic JDBC Connector implementation of
+ * <code>javax.sql.DataSource</code>
*/
public Object createConnectionFactory() {
logFine("In createConnectionFactory()");
@@ -104,59 +124,64 @@
}
/**
- * Creates a Connection Factory instance. The <code>ConnectionManager</code> implementation
- * of the application server is used here.
+ * Creates a Connection Factory instance. The <code>ConnectionManager</code>
+ * implementation of the application server is used here.
*
- * @param cxManager <code>ConnectionManager</code> passed by the application server
- * @return Generic JDBC Connector implementation of <code>javax.sql.DataSource</code>
+ * @param connectionManager <code>ConnectionManager</code> passed by the application
+ * server
+ * @return Generic JDBC Connector implementation of
+ * <code>javax.sql.DataSource</code>
*/
- public Object createConnectionFactory(jakarta.resource.spi.ConnectionManager cxManager) {
+ public Object createConnectionFactory(ConnectionManager connectionManager) {
logFine("In createConnectionFactory(jakarta.resource.spi.ConnectionManager cxManager)");
- javax.sql.DataSource cf = jdbcObjectsFactory.getDataSourceInstance(this, cxManager);
+ DataSource connectionFactory = jdbcObjectsFactory.getDataSourceInstance(this, connectionManager);
- if (cxManager instanceof jakarta.resource.spi.LazyEnlistableConnectionManager) {
- cm_ = (jakarta.resource.spi.LazyEnlistableConnectionManager) cxManager;
- isLazyCm_ = true;
+ if (connectionManager instanceof LazyEnlistableConnectionManager) {
+ this.connectionManager = (LazyEnlistableConnectionManager) connectionManager;
+ isLazyConnectionManager = true;
}
- return cf;
+
+ return connectionFactory;
}
/**
- * Creates a new physical connection to the underlying EIS resource
- * manager.
+ * Creates a new physical connection to the underlying EIS resource manager.
*
- * @param subject <code>Subject</code> instance passed by the application server
+ * @param subject <code>Subject</code> instance passed by the application server
* @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created
- * as a result of the invocation <code>getConnection(user, password)</code>
- * on the <code>DataSource</code> object
+ * as a result of the invocation <code>getConnection(user, password)</code> on
+ * the <code>DataSource</code> object
+ *
* @return <code>ManagedConnection</code> object created
* @throws ResourceException if there is an error in instantiating the
- * <code>DataSource</code> object used for the
- * creation of the <code>ManagedConnection</code> object
+ * <code>DataSource</code> object used for the creation of the
+ * <code>ManagedConnection</code> object
* @throws SecurityException if there ino <code>PasswordCredential</code> object
- * satisfying this request
- * @throws ResourceException if there is an error in allocating the
- * physical connection
+ * satisfying this request
+ * @throws ResourceException if there is an error in allocating the physical
+ * connection
*/
- public abstract jakarta.resource.spi.ManagedConnection createManagedConnection
- (javax.security.auth.Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException;
+ public abstract ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException;
/**
- * Check if this <code>ManagedConnectionFactoryImpl</code> is equal to
- * another <code>ManagedConnectionFactoryImpl</code>.
+ * Check if this <code>ManagedConnectionFactoryImpl</code> is equal to another
+ * <code>ManagedConnectionFactoryImpl</code>.
*
- * @param other <code>ManagedConnectionFactoryImpl</code> object for checking equality with
- * @return true if the property sets of both the
- * <code>ManagedConnectionFactoryImpl</code> objects are the same
- * false otherwise
+ * @param other <code>ManagedConnectionFactoryImpl</code> object for checking
+ * equality with
+ * @return true if the property sets of both the
+ * <code>ManagedConnectionFactoryImpl</code> objects are the same false
+ * otherwise
*/
public abstract boolean equals(Object other);
/**
- * Get the log writer for this <code>ManagedConnectionFactoryImpl</code> instance.
+ * Get the log writer for this <code>ManagedConnectionFactoryImpl</code>
+ * instance.
*
- * @return <code>PrintWriter</code> associated with this <code>ManagedConnectionFactoryImpl</code> instance
+ * @return <code>PrintWriter</code> associated with this
+ * <code>ManagedConnectionFactoryImpl</code> instance
* @see <code>setLogWriter</code>
*/
public java.io.PrintWriter getLogWriter() {
@@ -164,14 +189,16 @@
}
/**
- * Get the <code>ResourceAdapterImpl</code> for this <code>ManagedConnectionFactoryImpl</code> instance.
+ * Get the <code>ResourceAdapterImpl</code> for this
+ * <code>ManagedConnectionFactoryImpl</code> instance.
*
- * @return <code>ResourceAdapterImpl</code> associated with this <code>ManagedConnectionFactoryImpl</code> instance
+ * @return <code>ResourceAdapterImpl</code> associated with this
+ * <code>ManagedConnectionFactoryImpl</code> instance
* @see <code>setResourceAdapter</code>
*/
public jakarta.resource.spi.ResourceAdapter getResourceAdapter() {
logFine("In getResourceAdapter");
- return ra;
+ return resourceAdapter;
}
/**
@@ -185,58 +212,58 @@
}
/**
- * Returns a matched <code>ManagedConnection</code> from the candidate
- * set of <code>ManagedConnection</code> objects.
+ * Returns a matched <code>ManagedConnection</code> from the candidate set of
+ * <code>ManagedConnection</code> objects.
*
- * @param connectionSet <code>Set</code> of <code>ManagedConnection</code>
- * objects passed by the application server
- * @param subject passed by the application server
- * for retrieving information required for matching
- * @param cxRequestInfo <code>ConnectionRequestInfo</code> passed by the application server
- * for retrieving information required for matching
- * @return <code>ManagedConnection</code> that is the best match satisfying this request
- * @throws ResourceException if there is an error accessing the <code>Subject</code>
- * parameter or the <code>Set</code> of <code>ManagedConnection</code>
- * objects passed by the application server
+ * @param connectionSet <code>Set</code> of <code>ManagedConnection</code>
+ * objects passed by the application server
+ * @param subject passed by the application server for retrieving information
+ * required for matching
+ * @param cxRequestInfo <code>ConnectionRequestInfo</code> passed by the
+ * application server for retrieving information required for matching
+ * @return <code>ManagedConnection</code> that is the best match satisfying this
+ * request
+ * @throws ResourceException if there is an error accessing the
+ * <code>Subject</code> parameter or the <code>Set</code> of
+ * <code>ManagedConnection</code> objects passed by the application server
*/
- public jakarta.resource.spi.ManagedConnection matchManagedConnections(
- java.util.Set connectionSet, javax.security.auth.Subject subject, ConnectionRequestInfo cxRequestInfo)
- throws ResourceException {
+ public ManagedConnection matchManagedConnections(Set connectionSet, Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException {
logFine("In matchManagedConnections");
if (connectionSet == null) {
return null;
}
+ PasswordCredential passwordCredential = getPasswordCredential(this, subject, cxRequestInfo);
- PasswordCredential pc = SecurityUtils.getPasswordCredential(this, subject, cxRequestInfo);
-
- java.util.Iterator iter = connectionSet.iterator();
- ManagedConnectionImpl mc = null;
+ Iterator<ManagedConnectionImpl> iter = connectionSet.iterator();
+ ManagedConnectionImpl managedConnectionImpl = null;
while (iter.hasNext()) {
try {
- mc = (ManagedConnectionImpl) iter.next();
- } catch (java.util.NoSuchElementException nsee) {
- _logger.log(Level.SEVERE, "jdbc.exc_iter");
+ managedConnectionImpl = iter.next();
+ } catch (NoSuchElementException nsee) {
+ _logger.log(SEVERE, "jdbc.exc_iter");
throw new ResourceException(nsee.getMessage());
}
- if (pc == null && this.equals(mc.getManagedConnectionFactory())) {
- return mc;
- } else if (SecurityUtils.isPasswordCredentialEqual(pc, mc.getPasswordCredential())) {
- return mc;
+ if (passwordCredential == null && this.equals(managedConnectionImpl.getManagedConnectionFactory())) {
+ return managedConnectionImpl;
+ }
+
+ if (isPasswordCredentialEqual(passwordCredential, managedConnectionImpl.getPasswordCredential())) {
+ return managedConnectionImpl;
}
}
+
return null;
}
/**
- * This method returns a set of invalid <code>ManagedConnection</code>
- * objects chosen from a specified set of <code>ManagedConnection</code>
- * objects.
+ * This method returns a set of invalid <code>ManagedConnection</code> objects
+ * chosen from a specified set of <code>ManagedConnection</code> objects.
*
- * @param connectionSet a set of <code>ManagedConnection</code> objects
- * that need to be validated.
+ * @param connectionSet a set of <code>ManagedConnection</code> objects that
+ * need to be validated.
* @return a set of invalid <code>ManagedConnection</code> objects.
* @throws ResourceException generic exception.
*/
@@ -244,55 +271,49 @@
Iterator iter = connectionSet.iterator();
Set<ManagedConnectionImpl> invalidConnections = new HashSet<ManagedConnectionImpl>();
while (iter.hasNext()) {
- ManagedConnectionImpl mc = (ManagedConnectionImpl) iter.next();
+ ManagedConnectionImpl managedConnectionImpl = (ManagedConnectionImpl) iter.next();
try {
- isValid(mc);
+ isValid(managedConnectionImpl);
} catch (ResourceException re) {
- invalidConnections.add(mc);
- mc.connectionErrorOccurred(re, null);
- if (_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.invalid_connection", re);
- }
+ invalidConnections.add(managedConnectionImpl);
+ managedConnectionImpl.connectionErrorOccurred(re, null);
+ _logger.log(FINE, "jdbc.invalid_connection", re);
}
}
+
return invalidConnections;
}
- //GJCINT
-
/**
- * Checks if a <code>ManagedConnection</code> is to be validated or not
- * and validates it or returns.
+ * Checks if a <code>ManagedConnection</code> is to be validated or not and
+ * validates it or returns.
*
* @param mc <code>ManagedConnection</code> to be validated
- * @throws ResourceException if the connection is not valid or
- * if validation method is not proper
+ * @throws ResourceException if the connection is not valid or if validation
+ * method is not proper
*/
void isValid(ManagedConnectionImpl mc) throws ResourceException {
-
if (mc == null || mc.isTransactionInProgress()) {
return;
}
String conVal = spec.getDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED);
- boolean connectionValidationRequired =
- (conVal == null) ? false : Boolean.valueOf(conVal.toLowerCase(Locale.getDefault()));
+ boolean connectionValidationRequired = (conVal == null) ? false
+ : Boolean.valueOf(conVal.toLowerCase(Locale.getDefault()));
if (!connectionValidationRequired) {
return;
}
-
String validationMethod = spec.getDetail(DataSourceSpec.VALIDATIONMETHOD).toLowerCase(Locale.getDefault());
mc.checkIfValid();
/**
- * The above call checks if the actual physical connection
- * is usable or not.
+ * The above call checks if the actual physical connection is usable or not.
*/
java.sql.Connection con = mc.getActualConnection();
- if(validationMethod.equals("custom-validation")) {
+ if (validationMethod.equals("custom-validation")) {
isValidByCustomValidation(con, spec.getDetail(DataSourceSpec.VALIDATIONCLASSNAME));
} else if (validationMethod.equals("auto-commit")) {
isValidByAutoCommit(con);
@@ -306,18 +327,17 @@
}
/**
- * Checks if a <code>java.sql.Connection</code> is valid or not
- * by doing a custom validation using the validation class name specified.
+ * Checks if a <code>java.sql.Connection</code> is valid or not by doing a
+ * custom validation using the validation class name specified.
*
* @param con <code>java.sql.Connection</code> to be validated
* @throws ResourceException if the connection is not valid
*/
- protected void isValidByCustomValidation(java.sql.Connection con,
- String validationClassName) throws ResourceException {
+ protected void isValidByCustomValidation(java.sql.Connection con, String validationClassName)
+ throws ResourceException {
boolean isValid = false;
if (con == null) {
- throw new ResourceException("The connection is not valid as "
- + "the connection is null");
+ throw new ResourceException("The connection is not valid as " + "the connection is null");
}
try {
@@ -335,16 +355,15 @@
}
/**
- * Checks if a <code>java.sql.Connection</code> is valid or not
- * by checking its auto commit property.
+ * Checks if a <code>java.sql.Connection</code> is valid or not by checking its
+ * auto commit property.
*
* @param con <code>java.sql.Connection</code> to be validated
* @throws ResourceException if the connection is not valid
*/
protected void isValidByAutoCommit(java.sql.Connection con) throws ResourceException {
if (con == null) {
- throw new ResourceException("The connection is not valid as "
- + "the connection is null");
+ throw new ResourceException("The connection is not valid as " + "the connection is null");
}
try {
@@ -352,7 +371,7 @@
// dbCon.setAutoCommit(dbCon.getAutoCommit()) will cause problems with
// some drivers like sybase
// We do not validate connections that are already enlisted
- //in a transaction
+ // in a transaction
// We cycle autocommit to true and false to by-pass drivers that
// might cache the call to set autocomitt
// Also notice that some XA data sources will throw and exception if
@@ -375,16 +394,15 @@
}
/**
- * Checks if a <code>java.sql.Connection</code> is valid or not
- * by checking its meta data.
+ * Checks if a <code>java.sql.Connection</code> is valid or not by checking its
+ * meta data.
*
* @param con <code>java.sql.Connection</code> to be validated
* @throws ResourceException if the connection is not valid
*/
protected void isValidByMetaData(java.sql.Connection con) throws ResourceException {
if (con == null) {
- throw new ResourceException("The connection is not valid as "
- + "the connection is null");
+ throw new ResourceException("The connection is not valid as " + "the connection is null");
}
try {
@@ -396,40 +414,37 @@
}
/**
- * Checks if a <code>java.sql.Connection</code> is valid or not
- * by querying a table.
+ * Checks if a <code>java.sql.Connection</code> is valid or not by querying a
+ * table.
*
- * @param con <code>java.sql.Connection</code> to be validated
+ * @param connection <code>java.sql.Connection</code> to be validated
* @param tableName table which should be queried
* @throws ResourceException if the connection is not valid
*/
- protected void isValidByTableQuery(java.sql.Connection con,
- String tableName) throws ResourceException {
- if (con == null) {
- throw new ResourceException("The connection is not valid as "
- + "the connection is null");
+ protected void isValidByTableQuery(Connection connection, String tableName) throws ResourceException {
+ if (connection == null) {
+ throw new ResourceException("The connection is not valid as " + "the connection is null");
}
- java.sql.PreparedStatement stmt = null;
- java.sql.ResultSet rs = null;
+ PreparedStatement preparedStatement = null;
+ ResultSet resultSet = null;
try {
- final String statement = "SELECT COUNT(*) FROM " + tableName;
- stmt = con.prepareStatement(statement);
- rs = stmt.executeQuery();
+ preparedStatement = connection.prepareStatement("SELECT COUNT(*) FROM " + tableName);
+ resultSet = preparedStatement.executeQuery();
} catch (Exception sqle) {
_logger.log(Level.INFO, "jdbc.exc_table_validation", tableName);
throw new ResourceException(sqle);
} finally {
try {
- if (rs != null) {
- rs.close();
+ if (resultSet != null) {
+ resultSet.close();
}
} catch (Exception e1) {
}
try {
- if (stmt != null) {
- stmt.close();
+ if (preparedStatement != null) {
+ preparedStatement.close();
}
} catch (Exception e2) {
}
@@ -440,14 +455,13 @@
* Sets the isolation level specified in the <code>ConnectionRequestInfo</code>
* for the <code>ManagedConnection</code> passed.
*
- * @param mc <code>ManagedConnection</code>
- * @throws ResourceException if the isolation property is invalid
- * or if the isolation cannot be set over the connection
+ * @param managedConnectionImpl <code>ManagedConnection</code>
+ * @throws ResourceException if the isolation property is invalid or if the
+ * isolation cannot be set over the connection
*/
- protected void setIsolation(ManagedConnectionImpl mc) throws ResourceException {
-
- java.sql.Connection con = mc.getActualConnection();
- if (con == null) {
+ protected void setIsolation(ManagedConnectionImpl managedConnectionImpl) throws ResourceException {
+ Connection connection = managedConnectionImpl.getActualConnection();
+ if (connection == null) {
return;
}
@@ -455,63 +469,59 @@
if (tranIsolation != null && !tranIsolation.equals("")) {
int tranIsolationInt = getTransactionIsolationInt(tranIsolation);
try {
- con.setTransactionIsolation(tranIsolationInt);
- mc.setLastTransactionIsolationLevel(tranIsolationInt);
- } catch (java.sql.SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_tx_iso", sqle);
- throw new ResourceException("The transaction isolation could "
- + "not be set: " + sqle.getMessage());
+ connection.setTransactionIsolation(tranIsolationInt);
+ managedConnectionImpl.setLastTransactionIsolationLevel(tranIsolationInt);
+ } catch (SQLException sqle) {
+ _logger.log(SEVERE, "jdbc.exc_tx_iso", sqle);
+ throw new ResourceException("The transaction isolation could " + "not be set: " + sqle.getMessage());
}
}
}
/**
- * Resets the isolation level for the <code>ManagedConnection</code> passed.
- * If the transaction level is to be guaranteed to be the same as the one
- * present when this <code>ManagedConnection</code> was created, as specified
- * by the <code>ConnectionRequestInfo</code> passed, it sets the transaction
- * isolation level from the <code>ConnectionRequestInfo</code> passed. Else,
- * it sets it to the transaction isolation passed.
+ * Resets the isolation level for the <code>ManagedConnection</code> passed. If
+ * the transaction level is to be guaranteed to be the same as the one present
+ * when this <code>ManagedConnection</code> was created, as specified by the
+ * <code>ConnectionRequestInfo</code> passed, it sets the transaction isolation
+ * level from the <code>ConnectionRequestInfo</code> passed. Else, it sets it to
+ * the transaction isolation passed.
*
- * @param mc <code>ManagedConnection</code>
+ * @param managedConnectionImpl <code>ManagedConnection</code>
* @param tranIsol int
- * @throws ResourceException if the isolation property is invalid
- * or if the isolation cannot be set over the connection
+ * @throws ResourceException if the isolation property is invalid or if the
+ * isolation cannot be set over the connection
*/
- void resetIsolation(ManagedConnectionImpl mc, int tranIsol) throws ResourceException {
-
- java.sql.Connection con = mc.getActualConnection();
- if (con == null) {
+ void resetIsolation(ManagedConnectionImpl managedConnectionImpl, int tranIsol) throws ResourceException {
+ Connection connection = managedConnectionImpl.getActualConnection();
+ if (connection == null) {
return;
}
- String tranIsolation = spec.getDetail(DataSourceSpec.TRANSACTIONISOLATION);
- if (tranIsolation != null && !tranIsolation.equals("")) {
+ String transactionIsolation = spec.getDetail(DataSourceSpec.TRANSACTIONISOLATION);
+ if (transactionIsolation != null && !transactionIsolation.equals("")) {
String guaranteeIsolationLevel = spec.getDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL);
if (guaranteeIsolationLevel != null && !guaranteeIsolationLevel.equals("")) {
boolean guarantee = Boolean.valueOf(guaranteeIsolationLevel.toLowerCase(Locale.getDefault()));
if (guarantee) {
- int tranIsolationInt = getTransactionIsolationInt(tranIsolation);
+ int tranIsolationInt = getTransactionIsolationInt(transactionIsolation);
try {
- if (tranIsolationInt != con.getTransactionIsolation()) {
- con.setTransactionIsolation(tranIsolationInt);
+ if (tranIsolationInt != connection.getTransactionIsolation()) {
+ connection.setTransactionIsolation(tranIsolationInt);
}
- } catch (java.sql.SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_tx_iso", sqle);
- throw new ResourceException("The isolation level could not be set: "
- + sqle.getMessage());
+ } catch (SQLException sqle) {
+ _logger.log(SEVERE, "jdbc.exc_tx_iso", sqle);
+ throw new ResourceException("The isolation level could not be set: " + sqle.getMessage());
}
} else {
try {
- if (tranIsol != con.getTransactionIsolation()) {
- con.setTransactionIsolation(tranIsol);
+ if (tranIsol != connection.getTransactionIsolation()) {
+ connection.setTransactionIsolation(tranIsol);
}
- } catch (java.sql.SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_tx_iso", sqle);
- throw new ResourceException("The isolation level could not be set: "
- + sqle.getMessage());
+ } catch (SQLException sqle) {
+ _logger.log(SEVERE, "jdbc.exc_tx_iso", sqle);
+ throw new ResourceException("The isolation level could not be set: " + sqle.getMessage());
}
}
}
@@ -519,26 +529,27 @@
}
private void detectSqlTraceListeners() {
- //Check for sql-trace-listeners attribute.
+ // Check for sql-trace-listeners attribute.
String sqlTraceListeners = getSqlTraceListeners();
String delimiter = ",";
- if(sqlTraceListeners != null && !sqlTraceListeners.equals("null")) {
+ if (sqlTraceListeners != null && !sqlTraceListeners.equals("null")) {
sqlTraceDelegator = new SQLTraceDelegator(getPoolName(), getApplicationName(), getModuleName());
StringTokenizer st = new StringTokenizer(sqlTraceListeners, delimiter);
+
while (st.hasMoreTokens()) {
String sqlTraceListener = st.nextToken().trim();
- if(!sqlTraceListener.equals("")) {
+ if (!sqlTraceListener.equals("")) {
Class listenerClass = null;
SQLTraceListener listener = null;
Constructor[] constructors = null;
Class[] parameterTypes = null;
Object[] initargs = null;
- //Load the listener class
+ // Load the listener class
try {
listenerClass = Thread.currentThread().getContextClassLoader().loadClass(sqlTraceListener);
} catch (ClassNotFoundException ex) {
- _logger.log(Level.SEVERE, "jdbc.sql_trace_listener_cnfe", sqlTraceListener);
+ _logger.log(SEVERE, "jdbc.sql_trace_listener_cnfe", sqlTraceListener);
}
Class intf[] = listenerClass.getInterfaces();
for (int i = 0; i < intf.length; i++) {
@@ -550,22 +561,22 @@
constructors = listenerClass.getConstructors();
for (Constructor constructor : constructors) {
parameterTypes = constructor.getParameterTypes();
- //For now only the no argument constructors are allowed.
- //TODO should this be documented?
+ // For now only the no argument constructors are allowed.
+ // TODO should this be documented?
if (parameterTypes.length == 0) {
listener = (SQLTraceListener) constructor.newInstance(initargs);
}
}
} catch (InstantiationException ex) {
- _logger.log(Level.SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
+ _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
} catch (IllegalAccessException ex) {
- _logger.log(Level.SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
+ _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
} catch (IllegalArgumentException ex) {
- _logger.log(Level.SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
+ _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
} catch (InvocationTargetException ex) {
- _logger.log(Level.SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
+ _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
} catch (SecurityException ex) {
- _logger.log(Level.SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
+ _logger.log(SEVERE, "jdbc.sql_trace_listener_exception", ex.getMessage());
}
sqlTraceDelegator.registerSQLTraceListener(listener);
}
@@ -575,74 +586,79 @@
}
}
-
/**
- * Gets the integer equivalent of the string specifying
- * the transaction isolation.
+ * Gets the integer equivalent of the string specifying the transaction
+ * isolation.
*
* @param tranIsolation string specifying the isolation level
- * @return tranIsolationInt the <code>java.sql.Connection</code> constant
- * for the string specifying the isolation.
+ * @return tranIsolationInt the <code>java.sql.Connection</code> constant for
+ * the string specifying the isolation.
*/
private int getTransactionIsolationInt(String tranIsolation) throws ResourceException {
if (tranIsolation.equalsIgnoreCase("read-uncommitted")) {
- return java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
- } else if (tranIsolation.equalsIgnoreCase("read-committed")) {
- return java.sql.Connection.TRANSACTION_READ_COMMITTED;
- } else if (tranIsolation.equalsIgnoreCase("repeatable-read")) {
- return java.sql.Connection.TRANSACTION_REPEATABLE_READ;
- } else if (tranIsolation.equalsIgnoreCase("serializable")) {
- return java.sql.Connection.TRANSACTION_SERIALIZABLE;
- } else {
- throw new ResourceException("Invalid transaction isolation; the transaction "
- + "isolation level can be empty or any of the following: "
- + "read-uncommitted, read-committed, repeatable-read, serializable");
+ return Connection.TRANSACTION_READ_UNCOMMITTED;
}
+
+ if (tranIsolation.equalsIgnoreCase("read-committed")) {
+ return Connection.TRANSACTION_READ_COMMITTED;
+ }
+
+ if (tranIsolation.equalsIgnoreCase("repeatable-read")) {
+ return Connection.TRANSACTION_REPEATABLE_READ;
+ }
+
+ if (tranIsolation.equalsIgnoreCase("serializable")) {
+ return Connection.TRANSACTION_SERIALIZABLE;
+ }
+
+ throw new ResourceException(
+ "Invalid transaction isolation; the transaction " +
+ "isolation level can be empty or any of the following: " +
+ "read-uncommitted, read-committed, repeatable-read, serializable");
}
/**
- * Common operation performed by all the child MCFs before returning a created mc
+ * Common operation performed by all the child MCFs before returning a created
+ * mc
*/
- protected void validateAndSetIsolation(ManagedConnectionImpl mc) throws ResourceException {
+ protected void validateAndSetIsolation(ManagedConnectionImpl managedConnectionImpl) throws ResourceException {
try {
- isValid(mc);
- setIsolation(mc);
+ isValid(managedConnectionImpl);
+ setIsolation(managedConnectionImpl);
} catch (ResourceException e) {
- if (mc != null) {
+ if (managedConnectionImpl != null) {
try {
- mc.destroy();
+ managedConnectionImpl.destroy();
} catch (ResourceException e1) {
_logger.log(Level.WARNING, "jdbc.exc_destroy", e1);
}
}
- String msg = localStrings.getString("jdbc.exc_destroy", e.getMessage());
- ResourceAllocationException rae = new ResourceAllocationException(
- msg, e);
- throw rae;
+
+ throw new ResourceAllocationException(localStrings.getString("jdbc.exc_destroy", e.getMessage()), e);
}
}
private void detectStatementCachingSupport() {
String cacheSize = getStatementCacheSize();
- if(cacheSize != null){
- try{
+ if (cacheSize != null) {
+ try {
statementCacheSize = Integer.parseInt(cacheSize);
- //TODO-SC FINE log-level with Pool Name (if possible)
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "StatementCaching Size : " + statementCacheSize);
+ // TODO-SC FINE log-level with Pool Name (if possible)
+ if (_logger.isLoggable(FINE)) {
+ _logger.log(FINE, "StatementCaching Size : " + statementCacheSize);
}
- }catch(NumberFormatException nfe){
- if(_logger.isLoggable(Level.FINE)) {
- _logger.fine("Exception while setting StatementCacheSize : " +
- nfe.getMessage());
+ } catch (NumberFormatException nfe) {
+ if (_logger.isLoggable(FINE)) {
+ _logger.fine("Exception while setting StatementCacheSize : " + nfe.getMessage());
}
- //ignore
+ // ignore
}
}
}
/**
- * Set the log writer for this <code>ManagedConnectionFactoryImpl</code> instance.
+ * Set the log writer for this <code>ManagedConnectionFactoryImpl</code>
+ * instance.
*
* @param out <code>PrintWriter</code> passed by the application server
* @see <code>getLogWriter</code>
@@ -655,11 +671,11 @@
* Set the associated <code>ResourceAdapterImpl</code> JavaBean.
*
* @param ra <code>ResourceAdapterImpl</code> associated with this
- * <code>ManagedConnectionFactoryImpl</code> instance
+ * <code>ManagedConnectionFactoryImpl</code> instance
* @see <code>getResourceAdapter</code>
*/
public void setResourceAdapter(jakarta.resource.spi.ResourceAdapter ra) {
- this.ra = ra;
+ this.resourceAdapter = ra;
}
/**
@@ -788,18 +804,15 @@
if (isAssignable) {
spec.setDetail(DataSourceSpec.VALIDATIONCLASSNAME, className);
} else {
- //Validation Failed
- _logger.log(Level.SEVERE, "jdbc.set_custom_validation_class_name_failure", className);
- throw new ResourceException("The Custom validation class name is " +
- "not valid as it does not implement " +
- ConnectionValidation.class.getName());
+ // Validation Failed
+ _logger.log(SEVERE, "jdbc.set_custom_validation_class_name_failure", className);
+ throw new ResourceException("The Custom validation class name is "
+ + "not valid as it does not implement " + ConnectionValidation.class.getName());
}
} catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.set_custom_validation_class_name_failure",
- ex.getMessage());
+ _logger.log(SEVERE, "jdbc.set_custom_validation_class_name_failure", ex.getMessage());
} catch (ClassNotFoundException ex) {
- _logger.log(Level.SEVERE, "jdbc.set_custom_validation_class_name_failure",
- ex.getMessage());
+ _logger.log(SEVERE, "jdbc.set_custom_validation_class_name_failure", ex.getMessage());
}
}
@@ -850,18 +863,16 @@
return spec.getDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL);
}
- protected boolean isEqual(PasswordCredential pc, String user,
- String password) {
+ protected boolean isEqual(PasswordCredential pc, String user, String password) {
- //if equal get direct connection else
- //get connection with user and password.
+ // if equal get direct connection else
+ // get connection with user and password.
String thisUser = (pc == null) ? null : pc.getUserName();
char[] passwordArray = (pc == null) ? null : pc.getPassword();
char[] tmpPasswordArray = (password == null) ? null : password.toCharArray();
- return (isStringEqual(thisUser, user) &&
- Arrays.equals(passwordArray, tmpPasswordArray));
+ return (isStringEqual(thisUser, user) && Arrays.equals(passwordArray, tmpPasswordArray));
}
@@ -982,21 +993,21 @@
return spec.getDetail(DataSourceSpec.STATEMENTWRAPPING);
}
- public void setStatementCacheSize(String value){
+ public void setStatementCacheSize(String value) {
spec.setDetail(DataSourceSpec.STATEMENTCACHESIZE, value);
detectStatementCachingSupport();
}
- public String getStatementCacheSize(){
+ public String getStatementCacheSize() {
return spec.getDetail(DataSourceSpec.STATEMENTCACHESIZE);
}
- public void setStatementLeakTimeoutInSeconds(String value){
+ public void setStatementLeakTimeoutInSeconds(String value) {
spec.setDetail(DataSourceSpec.STATEMENTLEAKTIMEOUTINSECONDS, value);
detectStatementLeakSupport();
}
- public String getStatementLeakTimeoutInSeconds(){
+ public String getStatementLeakTimeoutInSeconds() {
return spec.getDetail(DataSourceSpec.STATEMENTLEAKTIMEOUTINSECONDS);
}
@@ -1047,13 +1058,14 @@
public void setStatementCacheType(String statementCacheType) {
spec.setDetail(DataSourceSpec.STATEMENTCACHETYPE, statementCacheType);
this.statementCacheType = getStatementCacheType();
- if(this.statementCacheType == null || this.statementCacheType.trim().equals("")) {
- if(_logger.isLoggable(Level.FINE)) {
- _logger.fine(" Default StatementCaching Type : " +
- localStrings.getString("jdbc.statement-cache.default.datastructure"));
+ if (this.statementCacheType == null || this.statementCacheType.trim().equals("")) {
+ if (_logger.isLoggable(FINE)) {
+ _logger.fine(
+ " Default StatementCaching Type : " +
+ localStrings.getString("jdbc.statement-cache.default.datastructure"));
}
} else {
- if(_logger.isLoggable(Level.FINE)) {
+ if (_logger.isLoggable(FINE)) {
_logger.fine("StatementCaching Type : " + this.statementCacheType);
}
}
@@ -1080,9 +1092,8 @@
}
public void setInitSql(String initSql) {
- //TODO remove case where "null" is checked. Might be a CLI/GUI bug.
- if(initSql != null && !initSql.equalsIgnoreCase("null") &&
- !initSql.equals("")) {
+ // TODO remove case where "null" is checked. Might be a CLI/GUI bug.
+ if (initSql != null && !initSql.equalsIgnoreCase("null") && !initSql.equals("")) {
spec.setDetail(DataSourceSpec.INITSQL, initSql);
}
}
@@ -1112,7 +1123,7 @@
}
public void setSqlTraceListeners(String sqlTraceListeners) {
- if(sqlTraceListeners != null) {
+ if (sqlTraceListeners != null) {
spec.setDetail(DataSourceSpec.SQLTRACELISTENERS, sqlTraceListeners);
detectSqlTraceListeners();
}
@@ -1223,15 +1234,15 @@
return spec.getDetail(DataSourceSpec.DELIMITER);
}
- public void setEscapeCharacter(String escapeCharacter){
+ public void setEscapeCharacter(String escapeCharacter) {
spec.setDetail(DataSourceSpec.ESCAPECHARACTER, escapeCharacter);
}
- public String getEscapeCharacter(){
+ public String getEscapeCharacter() {
return spec.getDetail(DataSourceSpec.ESCAPECHARACTER);
}
- /**
+ /**
* Sets the driver specific properties.
*
* @param driverProps <code>String</code>
@@ -1252,16 +1263,14 @@
return spec.getDetail(DataSourceSpec.DRIVERPROPERTIES);
}
- protected PoolInfo getPoolInfo(){
+ protected PoolInfo getPoolInfo() {
return new PoolInfo(getPoolName(), getApplicationName(), getModuleName());
}
- protected ManagedConnectionImpl constructManagedConnection(PooledConnection pc,
- Connection sqlCon, PasswordCredential passCred,
- ManagedConnectionFactoryImpl mcf) throws ResourceException {
- return new ManagedConnectionImpl(pc, sqlCon, passCred, mcf,
- getPoolInfo(), statementCacheSize, statementCacheType, sqlTraceDelegator,
- statementLeakTimeout, statementLeakReclaim);
+ protected ManagedConnectionImpl constructManagedConnection(PooledConnection pc, Connection sqlCon,
+ PasswordCredential passCred, ManagedConnectionFactoryImpl mcf) throws ResourceException {
+ return new ManagedConnectionImpl(pc, sqlCon, passCred, mcf, getPoolInfo(), statementCacheSize,
+ statementCacheType, sqlTraceDelegator, statementLeakTimeout, statementLeakReclaim);
}
/**
@@ -1271,10 +1280,10 @@
* @throws ResourceException
*/
public Object getDataSource() throws ResourceException {
- if (dsObjBuilder == null) {
- dsObjBuilder = new DataSourceObjectBuilder(spec);
+ if (dataSourceObjectBuilder == null) {
+ dataSourceObjectBuilder = new DataSourceObjectBuilder(spec);
}
- return dsObjBuilder.constructDataSourceObject();
+ return dataSourceObjectBuilder.constructDataSourceObject();
}
protected static final int JVM_OPTION_STATEMENT_WRAPPING_ON = 1;
@@ -1282,12 +1291,10 @@
protected static final int JVM_OPTION_STATEMENT_WRAPPING_NOT_SET = -1;
/**
- * This wrapStatement flag is used to enable disable wrapping the
- * statement objects. This can be enabled by passing jvm option,
- * com.sun.appserv.jdbc.wrapstatement = true.
- * This can be disabled by removing this option or by passing non true
- * value.
- * By default this will be disabled
+ * This wrapStatement flag is used to enable disable wrapping the statement
+ * objects. This can be enabled by passing jvm option,
+ * com.sun.appserv.jdbc.wrapstatement = true. This can be disabled by removing
+ * this option or by passing non true value. By default this will be disabled
*/
private static int wrapStatement = JVM_OPTION_STATEMENT_WRAPPING_NOT_SET;
@@ -1303,8 +1310,7 @@
*/
private static int getStatementWrappingJVMOption() {
int result = JVM_OPTION_STATEMENT_WRAPPING_NOT_SET;
- String str = System.getProperty(
- "com.sun.appserv.jdbc.wrapJdbcObjects");
+ String str = System.getProperty("com.sun.appserv.jdbc.wrapJdbcObjects");
if ("true".equalsIgnoreCase(str)) {
result = JVM_OPTION_STATEMENT_WRAPPING_ON;
} else if ("false".equalsIgnoreCase(str)) {
@@ -1314,9 +1320,9 @@
}
/**
- * 9.1 has attribute "wrap-statements" which will be overriden
- * when JVM option is specified as "true" or "false"
- * JVM Option will be deprecated in future versions.
+ * 9.1 has attribute "wrap-statements" which will be overridden when JVM option
+ * is specified as "true" or "false" JVM Option will be deprecated in future
+ * versions.
*/
protected void computeStatementWrappingStatus() {
@@ -1325,8 +1331,8 @@
if (statementWrappingString != null)
poolProperty = Boolean.valueOf(statementWrappingString);
- if (wrapStatement == JVM_OPTION_STATEMENT_WRAPPING_ON ||
- (wrapStatement == JVM_OPTION_STATEMENT_WRAPPING_NOT_SET && poolProperty)) {
+ if (wrapStatement == JVM_OPTION_STATEMENT_WRAPPING_ON
+ || (wrapStatement == JVM_OPTION_STATEMENT_WRAPPING_NOT_SET && poolProperty)) {
statementWrapping = true;
} else {
statementWrapping = false;
@@ -1345,10 +1351,9 @@
public JdbcObjectsFactory getJdbcObjectsFactory() {
return jdbcObjectsFactory;
}
- protected void logFine(String logMessage){
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, logMessage);
- }
+
+ protected void logFine(String logMessage) {
+ _logger.log(FINE, logMessage);
}
@Override
@@ -1356,71 +1361,63 @@
String poolMonitoringSubTreeRoot = getPoolMonitoringSubTreeRoot();
String sqlTraceListeners = getSqlTraceListeners();
- //Default values used in case sql tracing is OFF
+ // Default values used in case sql tracing is OFF
int sqlTraceCacheSize = 0;
long timeToKeepQueries = 0;
- if(sqlTraceListeners != null && !sqlTraceListeners.equals("null")) {
- if(getNumberOfTopQueriesToReport() != null && !getNumberOfTopQueriesToReport().equals("null")) {
- //Some value is set for this property
+ if (sqlTraceListeners != null && !sqlTraceListeners.equals("null")) {
+ if (getNumberOfTopQueriesToReport() != null && !getNumberOfTopQueriesToReport().equals("null")) {
+ // Some value is set for this property
sqlTraceCacheSize = Integer.parseInt(getNumberOfTopQueriesToReport());
} else {
- //No property by this name. default to 10 queries
+ // No property by this name. default to 10 queries
sqlTraceCacheSize = 10;
}
- if(getTimeToKeepQueriesInMinutes() != null && !getTimeToKeepQueriesInMinutes().equals("null")) {
- //Time-To-Keep-Queries property has been set
+ if (getTimeToKeepQueriesInMinutes() != null && !getTimeToKeepQueriesInMinutes().equals("null")) {
+ // Time-To-Keep-Queries property has been set
timeToKeepQueries = Integer.parseInt(getTimeToKeepQueriesInMinutes());
} else {
- //Default to 5 minutes after which cache is pruned.
+ // Default to 5 minutes after which cache is pruned.
timeToKeepQueries = 5;
- //Time to keep queries is set to 5 minutes because the timer
- //task will keep running till mcf is destroyed even if
- //monitoring is turned OFF.
+ // Time to keep queries is set to 5 minutes because the timer
+ // task will keep running till mcf is destroyed even if
+ // monitoring is turned OFF.
}
}
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("MCF Created");
- }
- if (statementCacheSize > 0 ||
- (sqlTraceListeners != null && !sqlTraceListeners.equals("null")) ||
- statementLeakTimeout > 0) {
+
+ _logger.finest("MCF Created");
+
+ if (statementCacheSize > 0 || (sqlTraceListeners != null && !sqlTraceListeners.equals("null"))
+ || statementLeakTimeout > 0) {
jdbcStatsProvider = new JdbcStatsProvider(getPoolName(), getApplicationName(), getModuleName(),
sqlTraceCacheSize, timeToKeepQueries);
- //get the poolname and use it to initialize the stats provider n register
- StatsProviderManager.register(
- "jdbc-connection-pool",
- PluginPoint.SERVER,
- poolMonitoringSubTreeRoot, jdbcStatsProvider);
- if(jdbcStatsProvider.getSqlTraceCache() != null) {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Scheduling timer task for sql trace caching");
- }
- Timer timer = ((com.sun.gjc.spi.ResourceAdapterImpl) ra).getTimer();
+
+ // Get the poolname and use it to initialize the stats provider n register
+ StatsProviderManager.register("jdbc-connection-pool", PluginPoint.SERVER, poolMonitoringSubTreeRoot,
+ jdbcStatsProvider);
+
+ if (jdbcStatsProvider.getSqlTraceCache() != null) {
+ _logger.finest("Scheduling timer task for sql trace caching");
+ Timer timer = ((ResourceAdapterImpl) resourceAdapter).getTimer();
jdbcStatsProvider.getSqlTraceCache().scheduleTimerTask(timer);
}
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Registered JDBCRA Stats Provider");
- }
+
+ _logger.finest("Registered JDBCRA Stats Provider");
}
}
@Override
public void mcfDestroyed() {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("MCF Destroyed");
- }
- if(jdbcStatsProvider != null) {
- if(jdbcStatsProvider.getSqlTraceCache() != null) {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Canceling timer task for sql trace caching");
- }
+ _logger.finest("MCF Destroyed");
+
+ if (jdbcStatsProvider != null) {
+ if (jdbcStatsProvider.getSqlTraceCache() != null) {
+ _logger.finest("Canceling timer task for sql trace caching");
jdbcStatsProvider.getSqlTraceCache().cancelTimerTask();
}
+
StatsProviderManager.unregister(jdbcStatsProvider);
jdbcStatsProvider = null;
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Unregistered JDBCRA Stats Provider");
- }
+ _logger.finest("Unregistered JDBCRA Stats Provider");
}
}
@@ -1430,10 +1427,9 @@
if (stmtLeakTimeout != null) {
statementLeakTimeout = Integer.parseInt(stmtLeakTimeout) * 1000L;
statementLeakReclaim = Boolean.valueOf(stmtLeakReclaim);
- if (_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "StatementLeakTimeout in seconds: "
- + statementLeakTimeout + " & StatementLeakReclaim: "
- + statementLeakReclaim + " for pool : " + getPoolInfo());
+ if (_logger.isLoggable(FINE)) {
+ _logger.log(FINE, "StatementLeakTimeout in seconds: " + statementLeakTimeout
+ + " & StatementLeakReclaim: " + statementLeakReclaim + " for pool : " + getPoolInfo());
}
}
}
@@ -1442,6 +1438,6 @@
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- ra = com.sun.gjc.spi.ResourceAdapterImpl.getInstance();
+ resourceAdapter = ResourceAdapterImpl.getInstance();
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionImpl.java
index b15dcc6..1ba4153 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionImpl.java
@@ -16,86 +16,103 @@
package com.sun.gjc.spi;
-import com.sun.appserv.connectors.internal.spi.BadConnectionEventListener;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.spi.base.*;
-import com.sun.gjc.spi.base.datastructure.Cache;
-import com.sun.gjc.spi.base.datastructure.CacheFactory;
-import com.sun.gjc.util.SQLTraceDelegator;
-import com.sun.gjc.util.StatementLeakDetector;
-import com.sun.logging.LogDomains;
-import org.glassfish.resourcebase.resources.api.PoolInfo;
+import static jakarta.resource.spi.ConnectionEvent.CONNECTION_ERROR_OCCURRED;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
-import jakarta.resource.NotSupportedException;
-import jakarta.resource.ResourceException;
-import jakarta.resource.spi.ConnectionEvent;
-import jakarta.resource.spi.ConnectionEventListener;
-import jakarta.resource.spi.security.PasswordCredential;
-import javax.security.auth.Subject;
-import javax.sql.PooledConnection;
-import javax.sql.XAConnection;
-import javax.transaction.xa.XAResource;
import java.io.PrintWriter;
import java.sql.CallableStatement;
+import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Hashtable;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import java.util.Set;
-import java.util.logging.Level;
import java.util.logging.Logger;
+import javax.security.auth.Subject;
+import javax.sql.PooledConnection;
+import javax.sql.XAConnection;
+import javax.transaction.xa.XAResource;
+
+import org.glassfish.resourcebase.resources.api.PoolInfo;
+
+import com.sun.appserv.connectors.internal.spi.BadConnectionEventListener;
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.spi.base.CacheObjectKey;
+import com.sun.gjc.spi.base.CallableStatementWrapper;
+import com.sun.gjc.spi.base.ConnectionHolder;
+import com.sun.gjc.spi.base.ConnectionWrapper;
+import com.sun.gjc.spi.base.PreparedStatementWrapper;
+import com.sun.gjc.spi.base.datastructure.Cache;
+import com.sun.gjc.spi.base.datastructure.CacheFactory;
+import com.sun.gjc.util.SQLTraceDelegator;
+import com.sun.gjc.util.StatementLeakDetector;
+import com.sun.logging.LogDomains;
+
+import jakarta.resource.NotSupportedException;
+import jakarta.resource.ResourceException;
+import jakarta.resource.spi.ConnectionEvent;
+import jakarta.resource.spi.ConnectionEventListener;
+import jakarta.resource.spi.DissociatableManagedConnection;
+import jakarta.resource.spi.LazyEnlistableManagedConnection;
+import jakarta.resource.spi.LocalTransaction;
+import jakarta.resource.spi.ManagedConnection;
+import jakarta.resource.spi.ManagedConnectionFactory;
+import jakarta.resource.spi.ManagedConnectionMetaData;
+import jakarta.resource.spi.security.PasswordCredential;
+
/**
* <code>ManagedConnection</code> implementation for Generic JDBC Connector.
*
* @author Evani Sai Surya Kiran
* @version 1.0, 02/07/22
*/
-public class ManagedConnectionImpl implements jakarta.resource.spi.ManagedConnection,
- jakarta.resource.spi.LazyEnlistableManagedConnection,
- jakarta.resource.spi.DissociatableManagedConnection {
+public class ManagedConnectionImpl
+ implements ManagedConnection, LazyEnlistableManagedConnection, DissociatableManagedConnection {
+
+ protected static final Logger _logger = LogDomains.getLogger(ManagedConnectionImpl.class, LogDomains.RSR_LOGGER);
+ protected static final StringManager localStrings = StringManager.getManager(DataSourceObjectBuilder.class);
public static final int ISNOTAPOOLEDCONNECTION = 0;
public static final int ISPOOLEDCONNECTION = 1;
public static final int ISXACONNECTION = 2;
- protected boolean isDestroyed = false;
+ protected boolean isDestroyed;
protected boolean isUsable = true;
- protected boolean initSqlExecuted = false;
- protected int connectionCount = 0;
+ protected boolean initSqlExecuted;
+ protected int connectionCount;
protected int connectionType = ISNOTAPOOLEDCONNECTION;
- protected PooledConnection pc = null;
- protected java.sql.Connection actualConnection = null;
+ protected PooledConnection pooledConnection;
+ protected java.sql.Connection actualConnection;
protected Hashtable connectionHandles;
protected PrintWriter logWriter;
protected PasswordCredential passwdCredential;
- private jakarta.resource.spi.ManagedConnectionFactory mcf = null;
- protected XAResource xar = null;
+ private ManagedConnectionFactory managedConnectionFactory;
+ protected XAResource xaResource;
- protected ConnectionHolder myLogicalConnection = null;
+ protected ConnectionHolder myLogicalConnection;
- //GJCINT
protected int lastTransactionIsolationLevel;
protected boolean isClean = true;
- protected boolean transactionInProgress = false;
+ protected boolean transactionInProgress;
- protected ConnectionEventListener listener = null;
-
- protected ConnectionEvent ce = null;
+ protected ConnectionEventListener listener;
+ protected ConnectionEvent connectionEvent;
private boolean defaultAutoCommitValue = true;
private boolean lastAutoCommitValue = defaultAutoCommitValue;
- private boolean markedForRemoval = false;
-
- //private boolean statemntWrapping;
+ private boolean markedForRemoval;
private int statementTimeout;
- private Cache statementCache = null;
+ private Cache statementCache;
private int cacheSize;
private String cacheType;
private boolean statementCaching;
@@ -106,53 +123,39 @@
private SQLTraceDelegator sqlTraceDelegator;
- protected final static Logger _logger;
+ private boolean aborted;
- static {
- _logger = LogDomains.getLogger(ManagedConnectionImpl.class, LogDomains.RSR_LOGGER);
- }
-
- protected static final StringManager localStrings =
- StringManager.getManager(DataSourceObjectBuilder.class);
-
- private boolean aborted = false;
-
- private DatabaseMetaData cachedDatabaseMetaData = null;
- private Boolean isClientInfoSupported = null;
+ private DatabaseMetaData cachedDatabaseMetaData;
+ private Boolean isClientInfoSupported;
/**
- * Constructor for <code>ManagedConnectionImpl</code>. The pooledConn parameter is expected
- * to be null and sqlConn parameter is the actual connection in case where
- * the actual connection is got from a non pooled datasource object. The
- * pooledConn parameter is expected to be non null and sqlConn parameter
- * is expected to be null in the case where the datasource object is a
- * connection pool datasource or an xa datasource.
+ * Constructor for <code>ManagedConnectionImpl</code>. The pooledConn parameter
+ * is expected to be null and sqlConn parameter is the actual connection in case
+ * where the actual connection is got from a non pooled datasource object. The
+ * pooledConn parameter is expected to be non null and sqlConn parameter is
+ * expected to be null in the case where the datasource object is a connection
+ * pool datasource or an xa datasource.
*
- * @param pooledConn <code>PooledConnection</code> object in case the
- * physical connection is to be obtained from a pooled
- * <code>DataSource</code>; null otherwise
- * @param sqlConn <code>java.sql.Connection</code> object in case the physical
- * connection is to be obtained from a non pooled <code>DataSource</code>;
- * null otherwise
- * @param passwdCred object conatining the
- * user and password for allocating the connection
+ * @param pooledConn <code>PooledConnection</code> object in case the physical
+ * connection is to be obtained from a pooled <code>DataSource</code>; null
+ * otherwise
+ * @param sqlConn <code>java.sql.Connection</code> object in case the physical
+ * connection is to be obtained from a non pooled <code>DataSource</code>; null
+ * otherwise
+ * @param passwdCred object conatining the user and password for allocating the
+ * connection
* @throws ResourceException if the <code>ManagedConnectionFactory</code> object
- * that created this <code>ManagedConnectionImpl</code> object
- * is not the same as returned by <code>PasswordCredential</code>
- * object passed
+ * that created this <code>ManagedConnectionImpl</code> object is not the same
+ * as returned by <code>PasswordCredential</code> object passed
*/
- public ManagedConnectionImpl(PooledConnection pooledConn, java.sql.Connection sqlConn,
- PasswordCredential passwdCred,
- jakarta.resource.spi.ManagedConnectionFactory mcf,
- PoolInfo poolInfo,
- int statementCacheSize, String statementCacheType,
- SQLTraceDelegator delegator,
- long statementLeakTimeout, boolean statementLeakReclaim)
+ public ManagedConnectionImpl(PooledConnection pooledConn, Connection sqlConn, PasswordCredential passwdCred,
+ ManagedConnectionFactory mcf, PoolInfo poolInfo, int statementCacheSize, String statementCacheType,
+ SQLTraceDelegator delegator, long statementLeakTimeout, boolean statementLeakReclaim)
throws ResourceException {
+
if (pooledConn == null && sqlConn == null) {
- String i18nMsg = localStrings.getString(
- "jdbc.conn_obj_null");
+ String i18nMsg = localStrings.getString("jdbc.conn_obj_null");
throw new ResourceException(i18nMsg);
}
@@ -160,21 +163,19 @@
actualConnection = sqlConn;
}
- pc = pooledConn;
+ pooledConnection = pooledConn;
connectionHandles = new Hashtable();
passwdCredential = passwdCred;
sqlTraceDelegator = delegator;
- this.mcf = mcf;
- if (passwdCredential != null &&
- this.mcf.equals(passwdCredential.getManagedConnectionFactory()) == false) {
+ this.managedConnectionFactory = mcf;
+ if (passwdCredential != null && this.managedConnectionFactory.equals(passwdCredential.getManagedConnectionFactory()) == false) {
- String i18nMsg = localStrings.getString(
- "jdbc.mc_construct_err");
+ String i18nMsg = localStrings.getString("jdbc.mc_construct_err");
throw new ResourceException(i18nMsg);
}
logWriter = mcf.getLogWriter();
- ce = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
+ connectionEvent = new ConnectionEvent(this, ConnectionEvent.CONNECTION_CLOSED);
tuneStatementCaching(poolInfo, statementCacheSize, statementCacheType);
tuneStatementLeakTracing(poolInfo, statementLeakTimeout, statementLeakReclaim);
}
@@ -184,42 +185,34 @@
}
private void executeInitSql(final String initSql) {
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.execute_init_sql_start");
- }
- java.sql.PreparedStatement stmt = null;
+ _logger.log(FINE, "jdbc.execute_init_sql_start");
+ PreparedStatement statement = null;
- if (initSql != null && !initSql.equalsIgnoreCase("null") &&
- !initSql.equals("")) {
- try {
- stmt = actualConnection.prepareStatement(initSql);
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.executing_init_sql", initSql);
- }
- stmt.execute();
+ if (initSql != null && !initSql.equalsIgnoreCase("null") && !initSql.equals("")) {
+ try {
+ statement = actualConnection.prepareStatement(initSql);
+ _logger.log(FINE, "jdbc.executing_init_sql", initSql);
+ statement.execute();
} catch (SQLException sqle) {
- _logger.log(Level.WARNING, "jdbc.exc_init_sql_error", initSql);
+ _logger.log(WARNING, "jdbc.exc_init_sql_error", initSql);
initSqlExecuted = false;
} finally {
try {
- if (stmt != null) {
- stmt.close();
+ if (statement != null) {
+ statement.close();
}
} catch (Exception e) {
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.exc_init_sql_error_stmt_close", e.getMessage());
+ if (_logger.isLoggable(FINE)) {
+ _logger.log(FINE, "jdbc.exc_init_sql_error_stmt_close", e.getMessage());
}
}
}
initSqlExecuted = true;
}
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.execute_init_sql_end");
- }
+ _logger.log(FINE, "jdbc.execute_init_sql_end");
}
- private void tuneStatementCaching(PoolInfo poolInfo, int statementCacheSize,
- String statementCacheType) {
+ private void tuneStatementCaching(PoolInfo poolInfo, int statementCacheSize, String statementCacheType) {
cacheSize = statementCacheSize;
cacheType = statementCacheType;
if (cacheSize > 0) {
@@ -232,21 +225,23 @@
}
}
- private void tuneStatementLeakTracing(PoolInfo poolInfo, long statementLeakTimeout,
- boolean statementLeakReclaim) {
+ private void tuneStatementLeakTracing(PoolInfo poolInfo, long statementLeakTimeout, boolean statementLeakReclaim) {
stmtLeakTimeout = statementLeakTimeout;
stmtLeakReclaim = statementLeakReclaim;
- if(stmtLeakTimeout > 0) {
- ManagedConnectionFactoryImpl spiMCF = (ManagedConnectionFactoryImpl) mcf;
+ if (stmtLeakTimeout > 0) {
+ ManagedConnectionFactoryImpl managedConnectionFactoryImpl = (ManagedConnectionFactoryImpl) managedConnectionFactory;
statementLeakTracing = true;
if (leakDetector == null) {
- leakDetector = new StatementLeakDetector(poolInfo, statementLeakTracing,
- stmtLeakTimeout, stmtLeakReclaim,
- ((com.sun.gjc.spi.ResourceAdapterImpl) spiMCF.getResourceAdapter()).getTimer());
+ leakDetector =
+ new StatementLeakDetector(
+ poolInfo, statementLeakTracing, stmtLeakTimeout,
+ stmtLeakReclaim,
+ ((ResourceAdapterImpl) managedConnectionFactoryImpl.getResourceAdapter()).getTimer());
}
}
}
+
/**
* Adds a connection event listener to the ManagedConnectionImpl instance.
*
@@ -261,75 +256,72 @@
* Used by the container to change the association of an application-level
* connection handle with a <code>ManagedConnectionImpl</code> instance.
*
- * @param connection <code>ConnectionHolder30</code> to be associated with
- * this <code>ManagedConnectionImpl</code> instance
- * @throws ResourceException if the physical connection is no more
- * valid or the connection handle passed is null
+ * @param connection <code>ConnectionHolder30</code> to be associated with this
+ * <code>ManagedConnectionImpl</code> instance
+ * @throws ResourceException if the physical connection is no more valid or the
+ * connection handle passed is null
*/
public void associateConnection(Object connection) throws ResourceException {
logFine("In associateConnection");
checkIfValid();
if (connection == null) {
- String i18nMsg = localStrings.getString(
- "jdbc.conn_handle_null");
- throw new ResourceException(i18nMsg);
+ throw new ResourceException(localStrings.getString("jdbc.conn_handle_null"));
}
- ConnectionHolder ch = (ConnectionHolder) connection;
- com.sun.gjc.spi.ManagedConnectionImpl mc = ch.getManagedConnection();
+ ConnectionHolder connectionHolder = (ConnectionHolder) connection;
+ ManagedConnectionImpl managedConnectionImpl = connectionHolder.getManagedConnection();
isClean = false;
- ch.associateConnection(actualConnection, this);
+ connectionHolder.associateConnection(actualConnection, this);
+
/**
- * The expectation from the above method is that the connection holder
- * replaces the actual sql connection it holds with the sql connection
- * handle being passed in this method call. Also, it replaces the reference
- * to the ManagedConnectionImpl instance with this ManagedConnectionImpl instance.
- * Any previous statements and result sets also need to be removed.
+ * The expectation from the above method is that the connection holder replaces
+ * the actual sql connection it holds with the sql connection handle being
+ * passed in this method call. Also, it replaces the reference to the
+ * ManagedConnectionImpl instance with this ManagedConnectionImpl instance. Any
+ * previous statements and result sets also need to be removed.
*/
-
- ch.setActive(true);
+ connectionHolder.setActive(true);
incrementCount();
- //associate the MC to the supplied logical connection similar to associating the logical connection
- //with this MC and actual-connection.
- myLogicalConnection = ch;
- //mc will be null in case we are lazily associating
- if (mc != null) {
- mc.decrementCount();
+ // associate the MC to the supplied logical connection similar to associating
+ // the logical connection
+ // with this MC and actual-connection.
+ myLogicalConnection = connectionHolder;
+
+ // managedConnection will be null in case we are lazily associating
+ if (managedConnectionImpl != null) {
+ managedConnectionImpl.decrementCount();
}
}
/**
* Application server calls this method to force any cleanup on the
* <code>ManagedConnectionImpl</code> instance. This method calls the invalidate
- * method on all ConnectionHandles associated with this <code>ManagedConnectionImpl</code>.
+ * method on all ConnectionHandles associated with this
+ * <code>ManagedConnectionImpl</code>.
*
* @throws ResourceException if the physical connection is no more valid
*/
public void cleanup() throws ResourceException {
logFine("In cleanup");
- //commenting this as cleanup is called after destroy in case of markConnectionAsBad()
- //checkIfValid();
/**
* may need to set the autocommit to true for the non-pooled case.
*/
- //GJCINT
isClean = true;
- ManagedConnectionFactoryImpl spiMCF = (ManagedConnectionFactoryImpl) mcf;
- resetConnectionProperties(spiMCF);
+ resetConnectionProperties((ManagedConnectionFactoryImpl) managedConnectionFactory);
}
/**
- * This method removes all the connection handles from the table
- * of connection handles and invalidates all of them so that any
- * operation on those connection handles throws an exception.
+ * This method removes all the connection handles from the table of connection
+ * handles and invalidates all of them so that any operation on those connection
+ * handles throws an exception.
*
- * @throws ResourceException if there is a problem in retrieving
- * the connection handles
+ * @throws ResourceException if there is a problem in retrieving the connection
+ * handles
*/
protected void invalidateAllConnectionHandles() throws ResourceException {
Set handles = connectionHandles.keySet();
@@ -339,17 +331,15 @@
ConnectionHolder ch = (ConnectionHolder) iter.next();
ch.invalidate();
}
- } catch (java.util.NoSuchElementException nsee) {
- throw new ResourceException("Could not find the connection handle: " + nsee.getMessage());
+ } catch (NoSuchElementException nsee) {
+ throw new ResourceException("Could not find the connection handle: " + nsee.getMessage(), nsee);
}
connectionHandles.clear();
}
private void clearStatementCache() {
if (statementCache != null) {
- if(_logger.isLoggable(Level.FINE)) {
- _logger.fine("Closing statements in statement cache");
- }
+ _logger.fine("Closing statements in statement cache");
statementCache.flushCache();
statementCache.clearCache();
}
@@ -358,27 +348,28 @@
/**
* Destroys the physical connection to the underlying resource manager.
*
- * @throws ResourceException if there is an error in closing the physical connection
+ * @throws ResourceException if there is an error in closing the physical
+ * connection
*/
public void destroy() throws ResourceException {
logFine("In destroy");
- //GJCINT
if (isDestroyed) {
return;
}
clearStatementCache();
- //Connection could be closed even before statement is closed. Connection
- //close need not call statement close() method.
- //When application uses a statement, leakDetector could be started.At
- //this point, there is a need to clear the statement leak tasks
+
+ // Connection could be closed even before statement is closed. Connection
+ // close need not call statement close() method.
+ // When application uses a statement, leakDetector could be started.At
+ // this point, there is a need to clear the statement leak tasks
if (leakDetector != null) {
leakDetector.clearAllStatementLeakTasks();
}
try {
if (connectionType == ISXACONNECTION || connectionType == ISPOOLEDCONNECTION) {
- pc.close();
- pc = null;
+ pooledConnection.close();
+ pooledConnection = null;
actualConnection = null;
} else {
actualConnection.close();
@@ -388,49 +379,35 @@
isDestroyed = true;
passwdCredential = null;
connectionHandles = null;
- String i18nMsg = localStrings.getString(
- "jdbc.error_in_destroy");
- ResourceException re = new ResourceException(
- i18nMsg + sqle.getMessage(), sqle);
- throw re;
+ throw new ResourceException(localStrings.getString("jdbc.error_in_destroy") + sqle.getMessage(), sqle);
}
+
isDestroyed = true;
passwdCredential = null;
connectionHandles = null;
}
/**
- * Creates a new connection handle for the underlying physical
- * connection represented by the <code>ManagedConnectionImpl</code> instance.
+ * Creates a new connection handle for the underlying physical connection
+ * represented by the <code>ManagedConnectionImpl</code> instance.
*
- * @param sub <code>Subject</code> parameter needed for authentication
- * @param cxReqInfo <code>ConnectionRequestInfo</code> carries the user
- * and password required for getting this connection.
- * @return Connection the connection handle <code>Object</code>
- * @throws ResourceException if there is an error in allocating the
- * physical connection from the pooled connection
- * @throws jakarta.resource.spi.SecurityException
- * if there is a mismatch between the
- * password credentials or reauthentication is requested
+ * @param sub <code>Subject</code> parameter needed for authentication
+ * @param cxReqInfo <code>ConnectionRequestInfo</code> carries the user and
+ * password required for getting this connection.
+ * @return Connection the connection handle <code>Object</code>
+ * @throws ResourceException if there is an error in allocating the physical
+ * connection from the pooled connection
+ * @throws jakarta.resource.spi.SecurityException if there is a mismatch between
+ * the password credentials or reauthentication is requested
*/
- public Object getConnection(Subject sub, jakarta.resource.spi.ConnectionRequestInfo cxReqInfo)
- throws ResourceException {
+ public Object getConnection(Subject sub, jakarta.resource.spi.ConnectionRequestInfo cxReqInfo) throws ResourceException {
logFine("In getConnection");
checkIfValid();
- /** Appserver any way doesnt bother about re-authentication today. So commenting this out now.
- com.sun.gjc.spi.ConnectionRequestInfo cxRequestInfo = (com.sun.gjc.spi.ConnectionRequestInfo) cxReqInfo;
- PasswordCredential passwdCred = SecurityUtils.getPasswordCredential(this.mcf, sub, cxRequestInfo);
- if(SecurityUtils.isPasswordCredentialEqual(this.passwdCredential, passwdCred) == false) {
- throw new jakarta.resource.spi.SecurityException("Re-authentication not supported");
- }
- **/
-
- //GJCINT
getActualConnection();
- ManagedConnectionFactoryImpl spiMCF = (ManagedConnectionFactoryImpl) mcf;
+ ManagedConnectionFactoryImpl managedConnectionFactoryImpl = (ManagedConnectionFactoryImpl) managedConnectionFactory;
- String statementTimeoutString = spiMCF.getStatementTimeout();
+ String statementTimeoutString = managedConnectionFactoryImpl.getStatementTimeout();
if (statementTimeoutString != null) {
int timeoutValue = Integer.parseInt(statementTimeoutString);
if (timeoutValue >= 0) {
@@ -438,14 +415,17 @@
}
}
- myLogicalConnection = spiMCF.getJdbcObjectsFactory().getConnection(
- actualConnection, this, cxReqInfo, spiMCF.isStatementWrappingEnabled(),
- sqlTraceDelegator);
+ myLogicalConnection =
+ managedConnectionFactoryImpl.getJdbcObjectsFactory()
+ .getConnection(
+ actualConnection, this, cxReqInfo,
+ managedConnectionFactoryImpl.isStatementWrappingEnabled(),
+ sqlTraceDelegator);
- //TODO : need to see if this should be executed for every getConnection
+ // TODO : need to see if this should be executed for every getConnection
if (!initSqlExecuted) {
- //Check if Initsql is set and execute it
- String initSql = spiMCF.getInitSql();
+ // Check if Initsql is set and execute it
+ String initSql = managedConnectionFactoryImpl.getInitSql();
executeInitSql(initSql);
}
incrementCount();
@@ -457,28 +437,30 @@
}
/**
- * Resett connection properties as connections are pooled by application server<br>
+ * Resett connection properties as connections are pooled by application
+ * server<br>
*
- * @param spiMCF
+ * @param managedConnectionFactoryImpl
* @throws ResourceException
*/
- private void resetConnectionProperties(ManagedConnectionFactoryImpl spiMCF) throws ResourceException {
+ private void resetConnectionProperties(ManagedConnectionFactoryImpl managedConnectionFactoryImpl) throws ResourceException {
if (isClean) {
- // If the ManagedConnection is clean, reset the transaction isolation level to what
- // it was when it was when this ManagedConnection was cleaned up depending on the
- // ConnectionRequestInfo passed.
- spiMCF.resetIsolation(this, lastTransactionIsolationLevel);
+ // If the ManagedConnection is clean, reset the transaction isolation level to
+ // what it was when it was when this ManagedConnection was cleaned up depending on
+ // the ConnectionRequestInfo passed.
+ managedConnectionFactoryImpl.resetIsolation(this, lastTransactionIsolationLevel);
- // reset the autocommit value of the connection if application has modified it.
+ // Reset the autocommit value of the connection if application has modified it.
resetAutoCommit();
}
}
/**
- * To reset AutoCommit of actual connection.
- * If the last-auto-commit value is different from default-auto-commit value, reset will happen.
- * If there is a transaction in progress (because of connection sharing), reset will not happen.
+ * To reset AutoCommit of actual connection. If the last-auto-commit value is
+ * different from default-auto-commit value, reset will happen. If there is a
+ * transaction in progress (because of connection sharing), reset will not
+ * happen.
*
* @throws ResourceException
*/
@@ -487,32 +469,32 @@
try {
actualConnection.setAutoCommit(defaultAutoCommitValue);
} catch (SQLException sqle) {
- String i18nMsg = localStrings.getString(
- "jdbc.error_during_setAutoCommit");
- throw new ResourceException(i18nMsg + sqle.getMessage(), sqle);
+ throw new ResourceException(localStrings.getString("jdbc.error_during_setAutoCommit") + sqle.getMessage(), sqle);
}
+
setLastAutoCommitValue(defaultAutoCommitValue);
}
}
/**
- * Returns an <code>LocalTransactionImpl</code> instance. The <code>LocalTransactionImpl</code> interface
- * is used by the container to manage local transactions for a RM instance.
+ * Returns an <code>LocalTransactionImpl</code> instance. The
+ * <code>LocalTransactionImpl</code> interface is used by the container to
+ * manage local transactions for a RM instance.
*
* @return <code>LocalTransactionImpl</code> instance
* @throws ResourceException if the physical connection is not valid
*/
- public jakarta.resource.spi.LocalTransaction getLocalTransaction() throws ResourceException {
+ public LocalTransaction getLocalTransaction() throws ResourceException {
logFine("In getLocalTransaction");
checkIfValid();
- return new com.sun.gjc.spi.LocalTransactionImpl(this);
+ return new LocalTransactionImpl(this);
}
/**
* Gets the log writer for this <code>ManagedConnectionImpl</code> instance.
*
* @return <code>PrintWriter</code> instance associated with this
- * <code>ManagedConnectionImpl</code> instance
+ * <code>ManagedConnectionImpl</code> instance
* @throws ResourceException if the physical connection is not valid
* @see <code>setLogWriter</code>
*/
@@ -524,28 +506,27 @@
}
/**
- * Gets the metadata information for this connection's underlying EIS
- * resource manager instance.
+ * Gets the metadata information for this connection's underlying EIS resource
+ * manager instance.
*
* @return <code>ManagedConnectionMetaData</code> instance
* @throws ResourceException if the physical connection is not valid
*/
- public jakarta.resource.spi.ManagedConnectionMetaData getMetaData() throws ResourceException {
+ public ManagedConnectionMetaData getMetaData() throws ResourceException {
logFine("In getMetaData");
checkIfValid();
- return new com.sun.gjc.spi.ManagedConnectionMetaDataImpl(this);
+ return new ManagedConnectionMetaDataImpl(this);
}
/**
* Returns an <code>XAResource</code> instance.
*
* @return <code>XAResource</code> instance
- * @throws ResourceException if the physical connection is not valid or
- * there is an error in allocating the
- * <code>XAResource</code> instance
+ * @throws ResourceException if the physical connection is not valid or there is
+ * an error in allocating the <code>XAResource</code> instance
* @throws NotSupportedException if underlying datasource is not an
- * <code>XADataSource</code>
+ * <code>XADataSource</code>
*/
public XAResource getXAResource() throws ResourceException {
logFine("In getXAResource");
@@ -553,13 +534,13 @@
if (connectionType == ISXACONNECTION) {
try {
- if (xar == null) {
+ if (xaResource == null) {
/**
* Using the wrapper XAResource.
*/
- xar = new com.sun.gjc.spi.XAResourceImpl(((XAConnection) pc).getXAResource(), this);
+ xaResource = new XAResourceImpl(((XAConnection) pooledConnection).getXAResource(), this);
}
- return xar;
+ return xaResource;
} catch (SQLException sqle) {
throw new ResourceException(sqle.getMessage(), sqle);
}
@@ -579,18 +560,18 @@
}
/**
- * This method is called from XAResource wrapper object
- * when its XAResource.start() has been called or from
- * LocalTransactionImpl object when its begin() method is called.
+ * This method is called from XAResource wrapper object when its
+ * XAResource.start() has been called or from LocalTransactionImpl object when
+ * its begin() method is called.
*/
void transactionStarted() {
transactionInProgress = true;
}
/**
- * This method is called from XAResource wrapper object
- * when its XAResource.end() has been called or from
- * LocalTransactionImpl object when its end() method is called.
+ * This method is called from XAResource wrapper object when its
+ * XAResource.end() has been called or from LocalTransactionImpl object when its
+ * end() method is called.
*/
void transactionCompleted() {
try {
@@ -606,22 +587,19 @@
}
}
} catch (java.lang.NullPointerException e) {
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.duplicateTxCompleted");
- }
+ _logger.log(FINE, "jdbc.duplicateTxCompleted");
}
if (markedForRemoval) {
if (aborted) {
- com.sun.appserv.connectors.internal.spi.BadConnectionEventListener bcel =
- (BadConnectionEventListener) listener;
- bcel.connectionAbortOccurred(ce);
- _logger.log(Level.INFO, "jdbc.markedForRemoval_conAborted");
+ BadConnectionEventListener badConnectionEventListener = (BadConnectionEventListener) listener;
+ badConnectionEventListener.connectionAbortOccurred(connectionEvent);
+ _logger.log(INFO, "jdbc.markedForRemoval_conAborted");
markedForRemoval = false;
myLogicalConnection.setClosed(true);
} else {
connectionErrorOccurred(null, null);
- _logger.log(Level.INFO, "jdbc.markedForRemoval_txCompleted");
+ _logger.log(INFO, "jdbc.markedForRemoval_txCompleted");
markedForRemoval = false;
}
}
@@ -630,8 +608,7 @@
}
/**
- * Checks if a this ManagedConnection is involved in a transaction
- * or not.
+ * Checks if a this ManagedConnection is involved in a transaction or not.
*/
public boolean isTransactionInProgress() {
return transactionInProgress;
@@ -641,7 +618,7 @@
* Sets the log writer for this <code>ManagedConnectionImpl</code> instance.
*
* @param out <code>PrintWriter</code> to be associated with this
- * <code>ManagedConnectionImpl</code> instance
+ * <code>ManagedConnectionImpl</code> instance
* @throws ResourceException if the physical connection is not valid
* @see <code>getLogWriter</code>
*/
@@ -651,8 +628,8 @@
}
/**
- * This method determines the type of the connection being held
- * in this <code>ManagedConnectionImpl</code>.
+ * This method determines the type of the connection being held in this
+ * <code>ManagedConnectionImpl</code>.
*
* @param pooledConn <code>PooledConnection</code>
* @return connection type
@@ -660,22 +637,24 @@
protected int getConnectionType(PooledConnection pooledConn) {
if (pooledConn == null) {
return ISNOTAPOOLEDCONNECTION;
- } else if (pooledConn instanceof XAConnection) {
- return ISXACONNECTION;
- } else {
- return ISPOOLEDCONNECTION;
}
+
+ if (pooledConn instanceof XAConnection) {
+ return ISXACONNECTION;
+ }
+
+ return ISPOOLEDCONNECTION;
}
/**
- * Returns the <code>ManagedConnectionFactory</code> instance that
- * created this <code>ManagedConnection</code> instance.
+ * Returns the <code>ManagedConnectionFactory</code> instance that created this
+ * <code>ManagedConnection</code> instance.
*
* @return <code>ManagedConnectionFactory</code> instance that created this
- * <code>ManagedConnection</code> instance
+ * <code>ManagedConnection</code> instance
*/
- public com.sun.gjc.spi.ManagedConnectionFactoryImpl getManagedConnectionFactory() {
- return (com.sun.gjc.spi.ManagedConnectionFactoryImpl) mcf;
+ public ManagedConnectionFactoryImpl getManagedConnectionFactory() {
+ return (ManagedConnectionFactoryImpl) managedConnectionFactory;
}
/**
@@ -683,15 +662,13 @@
*
* @return the physical <code>java.sql.Connection</code>
*/
- //GJCINT
- java.sql.Connection getActualConnection() throws ResourceException {
- //GJCINT
+ Connection getActualConnection() throws ResourceException {
if (connectionType == ISXACONNECTION || connectionType == ISPOOLEDCONNECTION) {
try {
if (actualConnection == null) {
- actualConnection = pc.getConnection();
+ actualConnection = pooledConnection.getConnection();
- //re-initialize lastAutoCommitValue such that resetAutoCommit() wont
+ // re-initialize lastAutoCommitValue such that resetAutoCommit() wont
// affect autoCommit of actualConnection
setLastAutoCommitValue(defaultAutoCommitValue);
}
@@ -700,14 +677,16 @@
throw new ResourceException(sqle.getMessage(), sqle);
}
}
+
return actualConnection;
}
/**
- * Returns the <code>PasswordCredential</code> object associated with this <code>ManagedConnection</code>.
+ * Returns the <code>PasswordCredential</code> object associated with this
+ * <code>ManagedConnection</code>.
*
* @return <code>PasswordCredential</code> associated with this
- * <code>ManagedConnection</code> instance
+ * <code>ManagedConnection</code> instance
*/
PasswordCredential getPasswordCredential() {
return passwdCredential;
@@ -715,129 +694,121 @@
/**
* Checks if this <code>ManagedConnection</code> is valid or not and throws an
- * exception if it is not valid. A <code>ManagedConnection</code> is not valid if
- * destroy has not been called and no physical connection error has
- * occurred rendering the physical connection unusable.
+ * exception if it is not valid. A <code>ManagedConnection</code> is not valid
+ * if destroy has not been called and no physical connection error has occurred
+ * rendering the physical connection unusable.
*
* @throws ResourceException if <code>destroy</code> has been called on this
- * <code>ManagedConnection</code> instance or if a
- * physical connection error occurred rendering it unusable
+ * <code>ManagedConnection</code> instance or if a physical connection error
+ * occurred rendering it unusable
*/
- //GJCINT
void checkIfValid() throws ResourceException {
if (isDestroyed || !isUsable) {
-
- String i18nMsg = localStrings.getString(
- "jdbc.mc_not_usable");
- throw new ResourceException(i18nMsg);
+ throw new ResourceException(localStrings.getString("jdbc.mc_not_usable"));
}
}
/**
- * This method is called by the <code>ConnectionHolder30</code> when its close method is
- * called. This <code>ManagedConnection</code> instance invalidates the connection handle
- * and sends a CONNECTION_CLOSED event to all the registered event listeners.
+ * This method is called by the <code>ConnectionHolder30</code> when its close
+ * method is called. This <code>ManagedConnection</code> instance invalidates
+ * the connection handle and sends a CONNECTION_CLOSED event to all the
+ * registered event listeners.
*
- * @param e Exception that may have occured while closing the connection handle
- * @param connHolder30Object <code>ConnectionHolder30</code> that has been closed
+ * @param e Exception that may have occured while closing the connection handle
+ * @param connHolder30Object <code>ConnectionHolder30</code> that has been
+ * closed
* @throws SQLException in case closing the sql connection got out of
- * <code>getConnection</code> on the underlying
- * <code>PooledConnection</code> throws an exception
+ * <code>getConnection</code> on the underlying <code>PooledConnection</code>
+ * throws an exception
*/
public void connectionClosed(Exception e, ConnectionHolder connHolder30Object) throws SQLException {
-
connHolder30Object.invalidate();
decrementCount();
- ce.setConnectionHandle(connHolder30Object);
+ connectionEvent.setConnectionHandle(connHolder30Object);
if (markedForRemoval && !transactionInProgress) {
- com.sun.appserv.connectors.internal.spi.BadConnectionEventListener bcel = (BadConnectionEventListener) listener;
- bcel.badConnectionClosed(ce);
- _logger.log(Level.INFO, "jdbc.markedForRemoval_conClosed");
+ BadConnectionEventListener badConnectionEventListener = (BadConnectionEventListener) listener;
+ badConnectionEventListener.badConnectionClosed(connectionEvent);
+ _logger.log(INFO, "jdbc.markedForRemoval_conClosed");
markedForRemoval = false;
} else {
- listener.connectionClosed(ce);
+ listener.connectionClosed(connectionEvent);
}
}
/**
- * This method is called by the <code>ConnectionHolder30</code> when it detects a connecion
- * related error.
+ * This method is called by the <code>ConnectionHolder30</code> when it detects
+ * a connecion related error.
*
- * @param e Exception that has occurred during an operation on the physical connection
- * @param connHolderObject <code>ConnectionHolder</code> that detected the physical
- * connection error
+ * @param e Exception that has occurred during an operation on the physical
+ * connection
+ * @param connectionHolder <code>ConnectionHolder</code> that detected the
+ * physical connection error
*/
- void connectionErrorOccurred(Exception e,
- ConnectionHolder connHolderObject) {
+ void connectionErrorOccurred(Exception e, ConnectionHolder connectionHolder) {
+ ConnectionEventListener connectionEventListener = this.listener;
- ConnectionEventListener cel = this.listener;
- ConnectionEvent ce = null;
- ce = e == null ? new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED)
- : new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, e);
- if (connHolderObject != null) {
- ce.setConnectionHandle(connHolderObject);
+ ConnectionEvent connectionEvent = e == null ?
+ new ConnectionEvent(this, CONNECTION_ERROR_OCCURRED) :
+ new ConnectionEvent(this, CONNECTION_ERROR_OCCURRED, e);
+
+ if (connectionHolder != null) {
+ connectionEvent.setConnectionHandle(connectionHolder);
}
- cel.connectionErrorOccurred(ce);
+ connectionEventListener.connectionErrorOccurred(connectionEvent);
isUsable = false;
}
-
/**
- * This method is called by the <code>XAResource</code> object when its start method
- * has been invoked.
+ * This method is called by the <code>XAResource</code> object when its start
+ * method has been invoked.
*/
void XAStartOccurred() {
try {
actualConnection.setAutoCommit(false);
} catch (Exception e) {
- _logger.log(Level.WARNING, "XA Start [ setAutoCommit ] failure ", e);
+ _logger.log(WARNING, "XA Start [ setAutoCommit ] failure ", e);
connectionErrorOccurred(e, null);
}
}
/**
- * This method is called by the <code>XAResource</code> object when its end method
- * has been invoked.
+ * This method is called by the <code>XAResource</code> object when its end
+ * method has been invoked.
*/
void XAEndOccurred() {
try {
actualConnection.setAutoCommit(true);
} catch (Exception e) {
- _logger.log(Level.WARNING, "XA End [ setAutoCommit ] failure ", e);
+ _logger.log(WARNING, "XA End [ setAutoCommit ] failure ", e);
connectionErrorOccurred(e, null);
}
}
/**
- * This method is called by a Connection Handle to check if it is
- * the active Connection Handle. If it is not the active Connection
- * Handle, this method throws an SQLException. Else, it
- * returns setting the active Connection Handle to the calling
- * Connection Handle object to this object if the active Connection
- * Handle is null.
+ * This method is called by a Connection Handle to check if it is the active
+ * Connection Handle. If it is not the active Connection Handle, this method
+ * throws an SQLException. Else, it returns setting the active Connection Handle
+ * to the calling Connection Handle object to this object if the active
+ * Connection Handle is null.
*
* @param ch <code>ConnectionHolder30</code> that requests this
- * <code>ManagedConnection</code> instance whether
- * it can be active or not
- * @throws SQLException in case the physical is not valid or
- * there is already an active connection handle
+ * <code>ManagedConnection</code> instance whether it can be active or not
+ * @throws SQLException in case the physical is not valid or there is already an
+ * active connection handle
*/
public void checkIfActive(ConnectionHolder ch) throws SQLException {
if (isDestroyed || !isUsable) {
-
- String i18nMsg = localStrings.getString(
- "jdbc.conn_not_usable");
- throw new SQLException(i18nMsg);
+ throw new SQLException(localStrings.getString("jdbc.conn_not_usable"));
}
}
/**
- * sets the connection type of this connection. This method is called
- * by the MCF while creating this ManagedConnection. Saves us a costly
- * instanceof operation in the getConnectionType
+ * sets the connection type of this connection. This method is called by the MCF
+ * while creating this ManagedConnection. Saves us a costly instanceof operation
+ * in the getConnectionType
*/
public void initializeConnectionType(int _connectionType) {
connectionType = _connectionType;
@@ -852,7 +823,7 @@
}
public void dissociateConnections() {
- if(myLogicalConnection != null){
+ if (myLogicalConnection != null) {
myLogicalConnection.dissociateConnection();
myLogicalConnection = null;
}
@@ -863,8 +834,8 @@
}
/**
- * To keep track of last auto commit value.
- * Helps to reset the auto-commit-value while giving new connection-handle.
+ * To keep track of last auto commit value. Helps to reset the auto-commit-value
+ * while giving new connection-handle.
*
* @param lastAutoCommitValue
*/
@@ -872,20 +843,17 @@
this.lastAutoCommitValue = lastAutoCommitValue;
}
-
public void markForRemoval(boolean flag) {
markedForRemoval = flag;
}
- public jakarta.resource.spi.ManagedConnectionFactory getMcf() {
- return mcf;
+ public ManagedConnectionFactory getMcf() {
+ return managedConnectionFactory;
}
-/*
- public boolean getStatementWrapping(){
- return statemntWrapping;
- }
-*/
+ /*
+ * public boolean getStatementWrapping(){ return statemntWrapping; }
+ */
public int getStatementTimeout() {
return statementTimeout;
@@ -901,7 +869,7 @@
* @return <code>DatabaseMetaData</code>
*/
public DatabaseMetaData getCachedDatabaseMetaData() throws ResourceException {
- if(cachedDatabaseMetaData == null){
+ if (cachedDatabaseMetaData == null) {
try {
cachedDatabaseMetaData = getActualConnection().getMetaData();
} catch (SQLException sqle) {
@@ -919,308 +887,291 @@
this.isClientInfoSupported = isClientInfoSupported;
}
- private void logFine(String logMessage){
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, logMessage);
- }
+ private void logFine(String logMessage) {
+ _logger.log(FINE, logMessage);
}
- public PreparedStatement prepareCachedStatement(
- ConnectionWrapper conWrapper, String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
+ public PreparedStatement prepareCachedStatement(ConnectionWrapper connection, String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
if (statementCaching) {
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.PREPARED_STATEMENT, resultSetType, resultSetConcurrency);
- //TODO-SC should a null check be done for statementCache?
- //TODO-SC refactor this method.
- PreparedStatementWrapper ps =
- (PreparedStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself and make sure that only a free stmt is returned
- if (ps != null) {
- if (isFree(ps)) {
- //Find if this ps is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!ps.isValid()) {
- statementCache.purge(ps);
- ps = conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, true);
- ps.setBusy(true);
- statementCache.addToCache(key, ps, false);
+ CacheObjectKey key =
+ new CacheObjectKey(sql, CacheObjectKey.PREPARED_STATEMENT, resultSetType, resultSetConcurrency);
+
+ // TODO-SC should a null check be done for statementCache?
+ // TODO-SC refactor this method.
+ PreparedStatementWrapper preparedStatement = (PreparedStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself
+ // and make sure that only a free stmt is returned
+ if (preparedStatement != null) {
+ if (isFree(preparedStatement)) {
+ // Find if this preparedStatement is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!preparedStatement.isValid()) {
+ statementCache.purge(preparedStatement);
+ preparedStatement = connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency, true);
+ preparedStatement.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
} else {
- //Valid ps
- ps.setBusy(true);
+ // Valid preparedStatement
+ preparedStatement.setBusy(true);
}
} else {
- return conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, false);
+ return connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency, false);
}
} else {
- ps = conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, true);
+ preparedStatement = connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency, true);
- ps.setBusy(true);
- statementCache.addToCache(key, ps, false);
-
+ preparedStatement.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
}
- return ps;
- } else
- return conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, false);
+
+ return preparedStatement;
+ }
+
+ return connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency, false);
}
- public PreparedStatement prepareCachedStatement(
- ConnectionWrapper conWrapper, String sql, int resultSetType,
+ public PreparedStatement prepareCachedStatement(ConnectionWrapper connection, String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability) throws SQLException {
if (statementCaching) {
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.PREPARED_STATEMENT, resultSetType,
- resultSetConcurrency, resultSetHoldability);
- //TODO-SC should a null check be done for statementCache?
- PreparedStatementWrapper ps =
- (PreparedStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself and make sure that only a free stmt is returned
- if (ps != null) {
- if (isFree(ps)) {
- //Find if this ps is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!ps.isValid()) {
- statementCache.purge(ps);
- ps = conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, true);
- ps.setBusy(true);
- statementCache.addToCache(key, ps, false);
+ CacheObjectKey key =
+ new CacheObjectKey(sql, CacheObjectKey.PREPARED_STATEMENT, resultSetType, resultSetConcurrency, resultSetHoldability);
+
+ // TODO-SC should a null check be done for statementCache?
+ PreparedStatementWrapper preparedStatement = (PreparedStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself
+ // and make sure that only a free stmt is returned
+ if (preparedStatement != null) {
+ if (isFree(preparedStatement)) {
+ // Find if this preparedStatement is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!preparedStatement.isValid()) {
+ statementCache.purge(preparedStatement);
+ preparedStatement = connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency,
+ resultSetHoldability, true);
+ preparedStatement.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
} else {
- //Valid ps
- ps.setBusy(true);
+ // Valid preparedStatement
+ preparedStatement.setBusy(true);
}
} else {
- return conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, false);
- }
- } else {
- ps = conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, true);
-
- statementCache.addToCache(key, ps, false);
- ps.setBusy(true);
- }
- return ps;
- } else
- return conWrapper.prepareCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, false);
- }
-
- public PreparedStatement prepareCachedStatement(
- ConnectionWrapper conWrapper, String sql, String[] columnNames)
- throws SQLException {
- if (statementCaching) {
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.PREPARED_STATEMENT, columnNames);
- //TODO-SC should a null check be done for statementCache?
- PreparedStatementWrapper ps =
- (PreparedStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself and make sure that only a free stmt is returned
- if (ps != null) {
- if (isFree(ps)) {
- //Find if this ps is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!ps.isValid()) {
- statementCache.purge(ps);
- ps = conWrapper.prepareCachedStatement(sql,
- columnNames, true);
- ps.setBusy(true);
- statementCache.addToCache(key, ps, false);
- } else {
- //Valid ps
- ps.setBusy(true);
- }
-
- } else {
- return conWrapper.prepareCachedStatement(sql, columnNames, false);
- }
- } else {
- ps = conWrapper.prepareCachedStatement(sql, columnNames, true);
-
- statementCache.addToCache(key, ps, false);
- ps.setBusy(true);
- }
- return ps;
- } else
- return conWrapper.prepareCachedStatement(sql, columnNames, false);
- }
-
- public PreparedStatement prepareCachedStatement(
- ConnectionWrapper conWrapper, String sql, int[] columnIndexes)
- throws SQLException {
- if (statementCaching) {
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.PREPARED_STATEMENT, columnIndexes);
- //TODO-SC should a null check be done for statementCache?
- PreparedStatementWrapper ps =
- (PreparedStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself and make sure that only a free stmt is returned
- if (ps != null) {
- if (isFree(ps)) {
- //Find if this ps is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!ps.isValid()) {
- statementCache.purge(ps);
- ps = conWrapper.prepareCachedStatement(sql,
- columnIndexes, true);
- ps.setBusy(true);
- statementCache.addToCache(key, ps, false);
- } else {
- //Valid ps
- ps.setBusy(true);
- }
-
- } else {
- return conWrapper.prepareCachedStatement(sql, columnIndexes, false);
- }
- } else {
- ps = conWrapper.prepareCachedStatement(sql, columnIndexes, true);
-
- statementCache.addToCache(key, ps, false);
- ps.setBusy(true);
- }
- return ps;
- } else
- return conWrapper.prepareCachedStatement(sql, columnIndexes, false);
- }
-
- public PreparedStatement prepareCachedStatement(
- ConnectionWrapper conWrapper, String sql, int autoGeneratedKeys)
- throws SQLException {
- if (statementCaching) {
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.PREPARED_STATEMENT, autoGeneratedKeys);
- //TODO-SC should a null check be done for statementCache?
- PreparedStatementWrapper ps =
- (PreparedStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself and make sure that only a free stmt is returned
- if (ps != null) {
- if (isFree(ps)) {
- //Find if this ps is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!ps.isValid()) {
- statementCache.purge(ps);
- ps = conWrapper.prepareCachedStatement(sql,
- autoGeneratedKeys, true);
- ps.setBusy(true);
- statementCache.addToCache(key, ps, false);
- } else {
- //Valid ps
- ps.setBusy(true);
- }
-
- } else {
- return conWrapper.prepareCachedStatement(sql, autoGeneratedKeys, false);
- }
- } else {
- ps = conWrapper.prepareCachedStatement(sql, autoGeneratedKeys, true);
-
- statementCache.addToCache(key, ps, false);
- ps.setBusy(true);
- }
- return ps;
- } else
- return conWrapper.prepareCachedStatement(sql, autoGeneratedKeys, false);
- }
-
- public CallableStatement prepareCachedCallableStatement(
- ConnectionWrapper conWrapper, String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
- if (statementCaching) {
- //Adding the sql as well as the Statement type "CS" to the CacheObjectKey object
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.CALLABLE_STATEMENT, resultSetType, resultSetConcurrency);
- CallableStatementWrapper cs =
- (CallableStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache
- //itself and make sure that only a free stmt is returned
- if (cs != null) {
- if (isFree(cs)) {
- //Find if this cs is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!cs.isValid()) {
- statementCache.purge(cs);
- cs = conWrapper.callableCachedStatement(sql, resultSetType,
- resultSetConcurrency, true);
- cs.setBusy(true);
- statementCache.addToCache(key, cs, false);
- } else {
- //Valid ps
- cs.setBusy(true);
- }
-
- } else {
- return conWrapper.callableCachedStatement(sql,
- resultSetType, resultSetConcurrency, false);
- }
- } else {
- cs = conWrapper.callableCachedStatement(sql, resultSetType,
- resultSetConcurrency, true);
-
- statementCache.addToCache(key, cs, false);
- cs.setBusy(true);
- }
- return cs;
- } else
- return conWrapper.callableCachedStatement(sql, resultSetType,
- resultSetConcurrency, false);
- }
-
- public CallableStatement prepareCachedCallableStatement(
- ConnectionWrapper conWrapper, String sql, int resultSetType,
- int resultSetConcurrency, int resultSetHoldability) throws SQLException {
- if (statementCaching) {
- //Adding the sql as well as the Statement type "CS" to the CacheObjectKey object
- CacheObjectKey key = new CacheObjectKey(sql,
- CacheObjectKey.CALLABLE_STATEMENT, resultSetType,
- resultSetConcurrency, resultSetHoldability);
- CallableStatementWrapper cs =
- (CallableStatementWrapper)
- statementCache.checkAndUpdateCache(key);
- //TODO-SC-DEFER can the usability (isFree()) check be done by the cache
- //itself and make sure that only a free stmt is returned
- if (cs != null) {
- if (isFree(cs)) {
- //Find if this cs is a valid one. If invalid, remove it
- //from the cache and prepare a new stmt & add it to cache
- if(!cs.isValid()) {
- statementCache.purge(cs);
- cs = conWrapper.callableCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, true);
- cs.setBusy(true);
- statementCache.addToCache(key, cs, false);
- } else {
- //Valid ps
- cs.setBusy(true);
- }
-
- } else {
- return conWrapper.callableCachedStatement(sql,
- resultSetType, resultSetConcurrency,
+ return connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency,
resultSetHoldability, false);
}
} else {
- cs = conWrapper.callableCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, true);
+ preparedStatement = connection.prepareCachedStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability,
+ true);
- statementCache.addToCache(key, cs, false);
- cs.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
+ preparedStatement.setBusy(true);
}
- return cs;
- } else
- return conWrapper.callableCachedStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, false);
+ return preparedStatement;
+ }
+
+ return connection.prepareCachedStatement(
+ sql, resultSetType, resultSetConcurrency, resultSetHoldability, false);
+ }
+
+ public PreparedStatement prepareCachedStatement(ConnectionWrapper connection, String sql, String[] columnNames) throws SQLException {
+ if (statementCaching) {
+ CacheObjectKey key = new CacheObjectKey(sql, CacheObjectKey.PREPARED_STATEMENT, columnNames);
+
+ // TODO-SC should a null check be done for statementCache?
+ PreparedStatementWrapper preparedStatement = (PreparedStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself
+ // and make sure that only a free stmt is returned
+ if (preparedStatement != null) {
+ if (isFree(preparedStatement)) {
+ // Find if this preparedStatement is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!preparedStatement.isValid()) {
+ statementCache.purge(preparedStatement);
+ preparedStatement = connection.prepareCachedStatement(sql, columnNames, true);
+ preparedStatement.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
+ } else {
+ // Valid preparedStatement
+ preparedStatement.setBusy(true);
+ }
+
+ } else {
+ return connection.prepareCachedStatement(sql, columnNames, false);
+ }
+ } else {
+ preparedStatement = connection.prepareCachedStatement(sql, columnNames, true);
+
+ statementCache.addToCache(key, preparedStatement, false);
+ preparedStatement.setBusy(true);
+ }
+
+ return preparedStatement;
+ }
+
+ return connection.prepareCachedStatement(sql, columnNames, false);
+ }
+
+ public PreparedStatement prepareCachedStatement(ConnectionWrapper connection, String sql, int[] columnIndexes) throws SQLException {
+ if (statementCaching) {
+ CacheObjectKey key = new CacheObjectKey(sql, CacheObjectKey.PREPARED_STATEMENT, columnIndexes);
+
+ // TODO-SC should a null check be done for statementCache?
+ PreparedStatementWrapper preparedStatement = (PreparedStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself
+ // and make sure that only a free stmt is returned
+ if (preparedStatement != null) {
+ if (isFree(preparedStatement)) {
+ // Find if this preparedStatement is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!preparedStatement.isValid()) {
+ statementCache.purge(preparedStatement);
+ preparedStatement = connection.prepareCachedStatement(sql, columnIndexes, true);
+ preparedStatement.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
+ } else {
+ // Valid preparedStatement
+ preparedStatement.setBusy(true);
+ }
+
+ } else {
+ return connection.prepareCachedStatement(sql, columnIndexes, false);
+ }
+ } else {
+ preparedStatement = connection.prepareCachedStatement(sql, columnIndexes, true);
+
+ statementCache.addToCache(key, preparedStatement, false);
+ preparedStatement.setBusy(true);
+ }
+
+ return preparedStatement;
+ }
+
+ return connection.prepareCachedStatement(sql, columnIndexes, false);
+ }
+
+ public PreparedStatement prepareCachedStatement(ConnectionWrapper connection, String sql, int autoGeneratedKeys) throws SQLException {
+ if (statementCaching) {
+ CacheObjectKey key = new CacheObjectKey(sql, CacheObjectKey.PREPARED_STATEMENT, autoGeneratedKeys);
+
+ // TODO-SC should a null check be done for statementCache?
+ PreparedStatementWrapper preparedStatement = (PreparedStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache itself
+ // and make sure that only a free stmt is returned
+ if (preparedStatement != null) {
+ if (isFree(preparedStatement)) {
+ // Find if this preparedStatement is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!preparedStatement.isValid()) {
+ statementCache.purge(preparedStatement);
+ preparedStatement = connection.prepareCachedStatement(sql, autoGeneratedKeys, true);
+ preparedStatement.setBusy(true);
+ statementCache.addToCache(key, preparedStatement, false);
+ } else {
+ // Valid preparedStatement
+ preparedStatement.setBusy(true);
+ }
+
+ } else {
+ return connection.prepareCachedStatement(sql, autoGeneratedKeys, false);
+ }
+ } else {
+ preparedStatement = connection.prepareCachedStatement(sql, autoGeneratedKeys, true);
+
+ statementCache.addToCache(key, preparedStatement, false);
+ preparedStatement.setBusy(true);
+ }
+
+ return preparedStatement;
+ }
+
+ return connection.prepareCachedStatement(sql, autoGeneratedKeys, false);
+ }
+
+ public CallableStatement prepareCachedCallableStatement(ConnectionWrapper connection, String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ if (statementCaching) {
+ // Adding the sql as well as the Statement type "CS" to the CacheObjectKey
+ // object
+ CacheObjectKey key = new CacheObjectKey(sql, CacheObjectKey.CALLABLE_STATEMENT, resultSetType, resultSetConcurrency);
+ CallableStatementWrapper callableStatement = (CallableStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache
+ // itself and make sure that only a free stmt is returned
+ if (callableStatement != null) {
+ if (isFree(callableStatement)) {
+ // Find if this callableStatement is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!callableStatement.isValid()) {
+ statementCache.purge(callableStatement);
+ callableStatement = connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency, true);
+ callableStatement.setBusy(true);
+ statementCache.addToCache(key, callableStatement, false);
+ } else {
+ // Valid callableStatement
+ callableStatement.setBusy(true);
+ }
+
+ } else {
+ return connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency, false);
+ }
+ } else {
+ callableStatement = connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency, true);
+
+ statementCache.addToCache(key, callableStatement, false);
+ callableStatement.setBusy(true);
+ }
+ return callableStatement;
+ }
+
+ return connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency, false);
+ }
+
+ public CallableStatement prepareCachedCallableStatement(ConnectionWrapper connection, String sql, int resultSetType,
+ int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+ if (statementCaching) {
+
+ // Adding the sql as well as the Statement type "CS" to the CacheObjectKey object
+ CacheObjectKey key = new CacheObjectKey(sql, CacheObjectKey.CALLABLE_STATEMENT, resultSetType,
+ resultSetConcurrency, resultSetHoldability);
+ CallableStatementWrapper callableStatement = (CallableStatementWrapper) statementCache.checkAndUpdateCache(key);
+
+ // TODO-SC-DEFER can the usability (isFree()) check be done by the cache
+ // itself and make sure that only a free stmt is returned
+ if (callableStatement != null) {
+ if (isFree(callableStatement)) {
+ // Find if this cs is a valid one. If invalid, remove it
+ // from the cache and prepare a new stmt & add it to cache
+ if (!callableStatement.isValid()) {
+ statementCache.purge(callableStatement);
+ callableStatement = connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency,
+ resultSetHoldability, true);
+ callableStatement.setBusy(true);
+ statementCache.addToCache(key, callableStatement, false);
+ } else {
+ // Valid ps
+ callableStatement.setBusy(true);
+ }
+
+ } else {
+ return connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency,
+ resultSetHoldability, false);
+ }
+ } else {
+ callableStatement = connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability,
+ true);
+
+ statementCache.addToCache(key, callableStatement, false);
+ callableStatement.setBusy(true);
+ }
+
+ return callableStatement;
+ }
+
+ return connection.callableCachedStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability, false);
}
boolean isFree(PreparedStatementWrapper cachedps) {
@@ -1236,7 +1187,7 @@
}
public void purgeStatementFromCache(PreparedStatement preparedStatement) {
- //TODO isValid check for preparedStatement?
+ // TODO isValid check for preparedStatement?
statementCache.purge(preparedStatement);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionMetaDataImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionMetaDataImpl.java
index 0ec7c53..f12cd20 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionMetaDataImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ManagedConnectionMetaDataImpl.java
@@ -16,110 +16,111 @@
package com.sun.gjc.spi;
+import static java.util.logging.Level.SEVERE;
+
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
import com.sun.logging.LogDomains;
import jakarta.resource.ResourceException;
-import java.sql.SQLException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import jakarta.resource.spi.ManagedConnectionMetaData;
+import jakarta.resource.spi.security.PasswordCredential;
/**
- * <code>ManagedConnectionMetaData</code> implementation for Generic JDBC Connector.
+ * <code>ManagedConnectionMetaData</code> implementation for Generic JDBC
+ * Connector.
*
* @author Evani Sai Surya Kiran
* @version 1.0, 02/08/03
*/
-public class ManagedConnectionMetaDataImpl implements jakarta.resource.spi.ManagedConnectionMetaData {
+public class ManagedConnectionMetaDataImpl implements ManagedConnectionMetaData {
- private java.sql.DatabaseMetaData dmd = null;
- private ManagedConnectionImpl mc;
+ private static Logger _logger = LogDomains.getLogger(ManagedConnectionMetaDataImpl.class, LogDomains.RSR_LOGGER);
- private static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(ManagedConnectionMetaDataImpl.class, LogDomains.RSR_LOGGER);
- }
-
- private boolean debug = false;
+ private DatabaseMetaData databaseMetaData;
+ private ManagedConnectionImpl managedConnection;
/**
* Constructor for <code>ManagedConnectionMetaDataImpl</code>
*
- * @param mc <code>ManagedConnection</code>
- * @throws <code>ResourceException</code> if getting the DatabaseMetaData object fails
+ * @param managedConnection <code>ManagedConnection</code>
+ * @throws <code>ResourceException</code> if getting the DatabaseMetaData object
+ * fails
*/
- public ManagedConnectionMetaDataImpl(ManagedConnectionImpl mc) throws ResourceException {
+ public ManagedConnectionMetaDataImpl(ManagedConnectionImpl managedConnection) throws ResourceException {
try {
- this.mc = mc;
- dmd = mc.getActualConnection().getMetaData();
+ this.managedConnection = managedConnection;
+ databaseMetaData = managedConnection.getActualConnection().getMetaData();
} catch (SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_md", sqle);
- throw new ResourceException(sqle.getMessage());
+ _logger.log(SEVERE, "jdbc.exc_md", sqle);
+ throw new ResourceException(sqle.getMessage(), sqle);
}
}
/**
- * Returns product name of the underlying EIS instance connected
- * through the ManagedConnection.
+ * Returns product name of the underlying EIS instance connected through the
+ * ManagedConnection.
*
* @return Product name of the EIS instance
* @throws <code>ResourceException</code>
*/
public String getEISProductName() throws ResourceException {
try {
- return dmd.getDatabaseProductName();
+ return databaseMetaData.getDatabaseProductName();
} catch (SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_eis_prodname", sqle);
- throw new ResourceException(sqle.getMessage());
+ _logger.log(SEVERE, "jdbc.exc_eis_prodname", sqle);
+ throw new ResourceException(sqle.getMessage(), sqle);
}
}
/**
- * Returns product version of the underlying EIS instance connected
- * through the ManagedConnection.
+ * Returns product version of the underlying EIS instance connected through the
+ * ManagedConnection.
*
* @return Product version of the EIS instance
* @throws <code>ResourceException</code>
*/
public String getEISProductVersion() throws ResourceException {
try {
- return dmd.getDatabaseProductVersion();
+ return databaseMetaData.getDatabaseProductVersion();
} catch (SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_eis_prodvers", sqle);
+ _logger.log(SEVERE, "jdbc.exc_eis_prodvers", sqle);
throw new ResourceException(sqle.getMessage(), sqle.getMessage());
}
}
/**
- * Returns maximum limit on number of active concurrent connections
- * that an EIS instance can support across client processes.
+ * Returns maximum limit on number of active concurrent connections that an EIS
+ * instance can support across client processes.
*
* @return Maximum limit for number of active concurrent connections
* @throws <code>ResourceException</code>
*/
public int getMaxConnections() throws ResourceException {
try {
- return dmd.getMaxConnections();
+ return databaseMetaData.getMaxConnections();
} catch (SQLException sqle) {
- _logger.log(Level.SEVERE, "jdbc.exc_eis_maxconn");
- throw new ResourceException(sqle.getMessage());
+ _logger.log(SEVERE, "jdbc.exc_eis_maxconn");
+ throw new ResourceException(sqle.getMessage(), sqle);
}
}
/**
- * Returns name of the user associated with the ManagedConnection instance. The name
- * corresponds to the resource principal under whose whose security context, a connection
- * to the EIS instance has been established.
+ * Returns name of the user associated with the ManagedConnection instance. The
+ * name corresponds to the resource principal under whose whose security
+ * context, a connection to the EIS instance has been established.
*
* @return name of the user
* @throws <code>ResourceException</code>
*/
public String getUserName() throws ResourceException {
- jakarta.resource.spi.security.PasswordCredential pc = mc.getPasswordCredential();
- if (pc != null) {
- return pc.getUserName();
+ PasswordCredential passwordCredential = managedConnection.getPasswordCredential();
+ if (passwordCredential != null) {
+ return passwordCredential.getUserName();
}
- return mc.getManagedConnectionFactory().getUser();
+ return managedConnection.getManagedConnectionFactory().getUser();
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ResourceAdapterImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ResourceAdapterImpl.java
index 953a414..4cf1148 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ResourceAdapterImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/ResourceAdapterImpl.java
@@ -16,18 +16,24 @@
package com.sun.gjc.spi;
-import com.sun.logging.LogDomains;
+import static jakarta.resource.spi.AuthenticationMechanism.CredentialInterface.PasswordCredential;
+import static java.util.logging.Level.SEVERE;
+
import java.util.Timer;
-import java.util.logging.Level;
import java.util.logging.Logger;
+
+import javax.transaction.xa.XAResource;
+
+import com.sun.logging.LogDomains;
+
import jakarta.resource.NotSupportedException;
import jakarta.resource.spi.ActivationSpec;
import jakarta.resource.spi.AuthenticationMechanism;
import jakarta.resource.spi.BootstrapContext;
import jakarta.resource.spi.Connector;
+import jakarta.resource.spi.ResourceAdapter;
import jakarta.resource.spi.UnavailableException;
import jakarta.resource.spi.endpoint.MessageEndpointFactory;
-import javax.transaction.xa.XAResource;
/**
* <code>ResourceAdapterImpl</code> implementation for Generic JDBC Connector.
@@ -42,36 +48,40 @@
eisType = "Database",
version = "1.0",
authMechanisms = {
- @AuthenticationMechanism(authMechanism="BasicPassword",
- credentialInterface=AuthenticationMechanism.CredentialInterface.PasswordCredential)
+ @AuthenticationMechanism(
+ authMechanism = "BasicPassword",
+ credentialInterface = PasswordCredential)
}
)
-public class ResourceAdapterImpl implements jakarta.resource.spi.ResourceAdapter {
- private static ResourceAdapterImpl ra;
+public class ResourceAdapterImpl implements ResourceAdapter {
+
+ private static Logger logger = LogDomains.getLogger(ResourceAdapterImpl.class, LogDomains.RSR_LOGGER);
+
+ private static ResourceAdapterImpl resourceAdapterImpl;
private BootstrapContext bootstrapContext;
private Timer timer;
- private static Logger _logger = LogDomains.getLogger(ResourceAdapterImpl.class, LogDomains.RSR_LOGGER);
public ResourceAdapterImpl() {
- if(ra == null){
- //we do not expect RA to be initialized multiple times as this is a System RAR
- ra = this;
+ if (resourceAdapterImpl == null) {
+ // We do not expect RA to be initialized multiple times as this is a System RAR
+ resourceAdapterImpl = this;
}
}
public static ResourceAdapterImpl getInstance() {
- if(ra == null) {
+ if (resourceAdapterImpl == null) {
throw new IllegalStateException("ResourceAdapter not initialized");
}
- return ra;
+
+ return resourceAdapterImpl;
}
/**
- * Empty method implementation for endpointActivation
- * which just throws <code>NotSupportedException</code>
+ * Empty method implementation for endpointActivation which just throws
+ * <code>NotSupportedException</code>
*
* @param mef <code>MessageEndpointFactory</code>
- * @param as <code>ActivationSpec</code>
+ * @param as <code>ActivationSpec</code>
* @throws <code>NotSupportedException</code>
*
*/
@@ -83,15 +93,15 @@
* Empty method implementation for endpointDeactivation
*
* @param mef <code>MessageEndpointFactory</code>
- * @param as <code>ActivationSpec</code>
+ * @param as <code>ActivationSpec</code>
*/
public void endpointDeactivation(MessageEndpointFactory mef, ActivationSpec as) {
}
/**
- * Empty method implementation for getXAResources
- * which just throws <code>NotSupportedException</code>
+ * Empty method implementation for getXAResources which just throws
+ * <code>NotSupportedException</code>
*
* @param specs <code>ActivationSpec</code> array
* @throws <code>NotSupportedException</code>
@@ -104,38 +114,35 @@
/**
* Empty implementation of start method
*
- * @param ctx <code>BootstrapContext</code>
+ * @param bootstrapContext <code>BootstrapContext</code>
*/
- public void start(BootstrapContext ctx) {
- this.bootstrapContext = ctx;
+ public void start(BootstrapContext bootstrapContext) {
+ this.bootstrapContext = bootstrapContext;
}
/**
* Empty implementation of stop method
*/
public void stop() {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Cancelling the timer");
- }
- if(timer != null) {
+ logger.finest("Cancelling the timer");
+ if (timer != null) {
timer.purge();
timer.cancel();
}
}
public Timer getTimer() {
- if(bootstrapContext != null) {
+ if (bootstrapContext != null) {
if (timer == null) {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Creating the timer");
- }
+ logger.finest("Creating the timer");
try {
timer = bootstrapContext.createTimer();
} catch (UnavailableException ex) {
- _logger.log(Level.SEVERE, "jdbc-ra.timer_creation_exception", ex.getMessage());
+ logger.log(SEVERE, "jdbc-ra.timer_creation_exception", ex.getMessage());
}
}
}
+
return timer;
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAManagedConnectionFactory.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAManagedConnectionFactory.java
index 25e1526..814239b 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAManagedConnectionFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAManagedConnectionFactory.java
@@ -16,116 +16,119 @@
package com.sun.gjc.spi;
+import static com.sun.gjc.spi.ManagedConnectionImpl.ISXACONNECTION;
+import static com.sun.gjc.util.SecurityUtils.getPasswordCredential;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+import static java.util.logging.Level.SEVERE;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+import javax.security.auth.Subject;
+import javax.sql.DataSource;
+import javax.sql.XAConnection;
+import javax.sql.XADataSource;
+
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.gjc.common.DataSourceObjectBuilder;
import com.sun.gjc.common.DataSourceSpec;
import com.sun.gjc.spi.base.AbstractDataSource;
-import com.sun.gjc.util.SecurityUtils;
+import com.sun.gjc.spi.base.ConnectionHolder;
import com.sun.logging.LogDomains;
import jakarta.resource.ResourceException;
+import jakarta.resource.spi.ConfigProperty;
+import jakarta.resource.spi.ConnectionDefinition;
import jakarta.resource.spi.ConnectionRequestInfo;
import jakarta.resource.spi.ResourceAllocationException;
import jakarta.resource.spi.security.PasswordCredential;
-import java.sql.SQLException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import jakarta.resource.spi.ConfigProperty;
-import jakarta.resource.spi.ConnectionDefinition;
/**
- * XA <code>ManagedConnectionFactory</code> implementation for Generic JDBC Connector.
+ * XA <code>ManagedConnectionFactory</code> implementation for Generic JDBC
+ * Connector.
*
* @author Evani Sai Surya Kiran
* @version 1.0, 02/07/27
*/
@ConnectionDefinition(
- connectionFactory = javax.sql.DataSource.class,
+ connectionFactory = DataSource.class,
connectionFactoryImpl = AbstractDataSource.class,
- connection = java.sql.Connection.class,
- connectionImpl = com.sun.gjc.spi.base.ConnectionHolder.class
+ connection = Connection.class,
+ connectionImpl = ConnectionHolder.class
)
public class XAManagedConnectionFactory extends ManagedConnectionFactoryImpl {
private transient javax.sql.XADataSource xaDataSourceObj;
- private static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(XAManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
- }
+ private static Logger _logger = LogDomains.getLogger(XAManagedConnectionFactory.class, LogDomains.RSR_LOGGER);
/**
- * Creates a new physical connection to the underlying EIS resource
- * manager.
+ * Creates a new physical connection to the underlying EIS resource manager.
*
- * @param subject <code>Subject</code> instance passed by the application server
- * @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created
- * as a result of the invocation <code>getConnection(user, password)</code>
- * on the <code>DataSource</code> object
+ * @param subject <code>Subject</code> instance passed by the application server
+ * @param connectionRequestInfo <code>ConnectionRequestInfo</code> which may be created
+ * as a result of the invocation <code>getConnection(user, password)</code> on
+ * the <code>DataSource</code> object
+ *
* @return <code>ManagedConnection</code> object created
- * @throws ResourceException if there is an error in instantiating the
- * <code>DataSource</code> object used for the
- * creation of the <code>ManagedConnection</code> object
- * @throws SecurityException if there ino <code>PasswordCredential</code> object
- * satisfying this request
+ * @throws ResourceException if there is an error in instantiating the
+ * <code>DataSource</code> object used for the creation of the
+ * <code>ManagedConnection</code> object
+ * @throws SecurityException if there ino <code>PasswordCredential</code> object
+ * satisfying this request
* @throws ResourceAllocationException if there is an error in allocating the
- * physical connection
+ * physical connection
*/
- public jakarta.resource.spi.ManagedConnection createManagedConnection(javax.security.auth.Subject subject,
- ConnectionRequestInfo cxRequestInfo) throws ResourceException {
+ public jakarta.resource.spi.ManagedConnection createManagedConnection(Subject subject, ConnectionRequestInfo connectionRequestInfo) throws ResourceException {
logFine("In createManagedConnection");
- PasswordCredential pc = SecurityUtils.getPasswordCredential(this, subject, cxRequestInfo);
+ PasswordCredential passwordCredential = getPasswordCredential(this, subject, connectionRequestInfo);
+ XADataSource dataSource = getDataSource();
- javax.sql.XADataSource dataSource = getDataSource();
-
- javax.sql.XAConnection xaConn = null;
- ManagedConnectionImpl mc = null;
+ XAConnection xaConnection = null;
+ ManagedConnectionImpl managedConnection = null;
try {
- /* For the case where the user/passwd of the connection pool is
- * equal to the PasswordCredential for the connection request
- * get a connection from this pool directly.
- * for all other conditions go create a new connection
- */
- if (isEqual(pc, getUser(), getPassword())) {
- xaConn = dataSource.getXAConnection();
+ /*
+ * For the case where the user/passwd of the connection pool is equal to the
+ * PasswordCredential for the connection request get a connection from this pool
+ * directly. for all other conditions go create a new connection
+ */
+ if (isEqual(passwordCredential, getUser(), getPassword())) {
+ xaConnection = dataSource.getXAConnection();
} else {
- xaConn = dataSource.getXAConnection(pc.getUserName(),
- new String(pc.getPassword()));
+ xaConnection = dataSource.getXAConnection(
+ passwordCredential.getUserName(),
+ new String(passwordCredential.getPassword()));
}
-
- } catch (java.sql.SQLException sqle) {
- //_logger.log(Level.WARNING, "jdbc.exc_create_xa_conn",sqle);
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.exc_create_xa_conn", sqle);
- }
- StringManager sm = StringManager.getManager(
- DataSourceObjectBuilder.class);
+ } catch (SQLException sqle) {
+ _logger.log(FINE, "jdbc.exc_create_xa_conn", sqle);
+ StringManager sm = StringManager.getManager(DataSourceObjectBuilder.class);
String msg = sm.getString("jdbc.cannot_allocate_connection", sqle.getMessage());
throw new ResourceAllocationException(msg, sqle);
}
- try{
- mc = constructManagedConnection(
- xaConn, null, pc, this);
-
- mc.initializeConnectionType(ManagedConnectionImpl.ISXACONNECTION);
- //GJCINT
- validateAndSetIsolation(mc);
+ try {
+ managedConnection = constructManagedConnection(xaConnection, null, passwordCredential, this);
+ managedConnection.initializeConnectionType(ISXACONNECTION);
+ // GJCINT
+ validateAndSetIsolation(managedConnection);
} finally {
- if (mc == null) {
- if (xaConn != null) {
+ if (managedConnection == null) {
+ if (xaConnection != null) {
try {
- xaConn.close();
+ xaConnection.close();
} catch (SQLException e) {
- _logger.log(Level.FINEST, "Exception while closing connection : createManagedConnection" + xaConn);
+ _logger.log(FINEST,
+ "Exception while closing connection : createManagedConnection" + xaConnection);
}
}
}
}
- return mc;
+
+ return managedConnection;
}
/**
@@ -137,44 +140,17 @@
public javax.sql.XADataSource getDataSource() throws ResourceException {
if (xaDataSourceObj == null) {
try {
- xaDataSourceObj = (javax.sql.XADataSource) super.getDataSource();
+ xaDataSourceObj = (XADataSource) super.getDataSource();
} catch (ClassCastException cce) {
- _logger.log(Level.SEVERE, "jdbc.exc_cce_XA", cce);
+ _logger.log(SEVERE, "jdbc.exc_cce_XA", cce);
throw new ResourceException(cce.getMessage());
}
}
+
return xaDataSourceObj;
}
/**
- * Check if this <code>ManagedConnectionFactory</code> is equal to
- * another <code>ManagedConnectionFactory</code>.
- *
- * @param other <code>ManagedConnectionFactory</code> object for checking equality with
- * @return true if the property sets of both the
- * <code>ManagedConnectionFactory</code> objects are the same
- * false otherwise
- */
- public boolean equals(Object other) {
- logFine("In equals");
- /**
- * The check below means that two ManagedConnectionFactory objects are equal
- * if and only if their properties are the same.
- */
- if (other instanceof com.sun.gjc.spi.XAManagedConnectionFactory) {
- com.sun.gjc.spi.XAManagedConnectionFactory otherMCF =
- (com.sun.gjc.spi.XAManagedConnectionFactory) other;
- return this.spec.equals(otherMCF.spec);
- }
- return false;
- }
-
- @Override
- public int hashCode() {
- return 31 * 7 + (spec.hashCode());
- }
-
- /**
* Sets the class name of the data source
*
* @param className <code>String</code>
@@ -304,4 +280,32 @@
public String getPropertyCycle() {
return spec.getDetail(DataSourceSpec.PROPERTYCYCLE);
}
+
+ /**
+ * Check if this <code>ManagedConnectionFactory</code> is equal to another
+ * <code>ManagedConnectionFactory</code>.
+ *
+ * @param other <code>ManagedConnectionFactory</code> object for checking
+ * equality with
+ * @return true if the property sets of both the
+ * <code>ManagedConnectionFactory</code> objects are the same false otherwise
+ */
+ public boolean equals(Object other) {
+ logFine("In equals");
+ /**
+ * The check below means that two ManagedConnectionFactory objects are equal if
+ * and only if their properties are the same.
+ */
+ if (other instanceof XAManagedConnectionFactory) {
+ XAManagedConnectionFactory otherMCF = (XAManagedConnectionFactory) other;
+ return this.spec.equals(otherMCF.spec);
+ }
+
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return 31 * 7 + (spec.hashCode());
+ }
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAResourceImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAResourceImpl.java
index 67fb1eb..bf4905f 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAResourceImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/XAResourceImpl.java
@@ -28,65 +28,64 @@
*/
public class XAResourceImpl implements XAResource {
- XAResource xar;
- ManagedConnectionImpl mc;
+ XAResource xaResource;
+ ManagedConnectionImpl managedConnectionImpl;
/**
* Constructor for XAResourceImpl
*
- * @param xar <code>XAResource</code>
- * @param mc <code>ManagedConnection</code>
+ * @param xaResource <code>XAResource</code>
+ * @param managedConnection <code>ManagedConnection</code>
*/
- public XAResourceImpl(XAResource xar, ManagedConnectionImpl mc) {
- this.xar = xar;
- this.mc = mc;
+ public XAResourceImpl(XAResource xaResource, ManagedConnectionImpl managedConnection) {
+ this.xaResource = xaResource;
+ this.managedConnectionImpl = managedConnection;
}
/**
* Commit the global transaction specified by xid.
*
- * @param xid A global transaction identifier
+ * @param xid A global transaction identifier
* @param onePhase If true, the resource manager should use a one-phase commit
- * protocol to commit the work done on behalf of xid.
+ * protocol to commit the work done on behalf of xid.
*/
public void commit(Xid xid, boolean onePhase) throws XAException {
- //the mc.transactionCompleted call has come here because
- //the transaction *actually* completes after the flow
- //reaches here. the end() method might not really signal
- //completion of transaction in case the transaction is
- //suspended. In case of transaction suspension, the end
- //method is still called by the transaction manager
+ // the mc.transactionCompleted call has come here because
+ // the transaction *actually* completes after the flow
+ // reaches here. the end() method might not really signal
+ // completion of transaction in case the transaction is
+ // suspended. In case of transaction suspension, the end
+ // method is still called by the transaction manager
try {
- xar.commit(xid, onePhase);
+ xaResource.commit(xid, onePhase);
} catch (XAException xae) {
throw xae;
} catch (Exception e) {
throw new XAException(e.getMessage());
} finally {
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
}
}
/**
* Ends the work performed on behalf of a transaction branch.
*
- * @param xid A global transaction identifier that is the same as what
- * was used previously in the start method.
+ * @param xid A global transaction identifier that is the same as what was used
+ * previously in the start method.
* @param flags One of TMSUCCESS, TMFAIL, or TMSUSPEND
*/
public void end(Xid xid, int flags) throws XAException {
- xar.end(xid, flags);
- //GJCINT
- //mc.transactionCompleted();
+ xaResource.end(xid, flags);
}
/**
- * Tell the resource manager to forget about a heuristically completed transaction branch.
+ * Tell the resource manager to forget about a heuristically completed
+ * transaction branch.
*
* @param xid A global transaction identifier
*/
public void forget(Xid xid) throws XAException {
- xar.forget(xid);
+ xaResource.forget(xid);
}
/**
@@ -96,47 +95,47 @@
* @return the transaction timeout value in seconds
*/
public int getTransactionTimeout() throws XAException {
- return xar.getTransactionTimeout();
+ return xaResource.getTransactionTimeout();
}
/**
* This method is called to determine if the resource manager instance
- * represented by the target object is the same as the resouce manager
- * instance represented by the parameter xares.
+ * represented by the target object is the same as the resouce manager instance
+ * represented by the parameter xares.
*
- * @param xares An <code>XAResource</code> object whose resource manager
- * instance is to be compared with the resource
+ * @param xaResource An <code>XAResource</code> object whose resource manager
+ * instance is to be compared with the resource
* @return true if it's the same RM instance; otherwise false.
*/
- public boolean isSameRM(XAResource xares) throws XAException {
- return xar.isSameRM(xares);
+ public boolean isSameRM(XAResource xaResource) throws XAException {
+ return this.xaResource.isSameRM(xaResource);
}
/**
- * Ask the resource manager to prepare for a transaction commit
- * of the transaction specified in xid.
+ * Ask the resource manager to prepare for a transaction commit of the
+ * transaction specified in xid.
*
* @param xid A global transaction identifier
- * @return A value indicating the resource manager's vote on the
- * outcome of the transaction. The possible values
- * are: XA_RDONLY or XA_OK. If the resource manager wants
- * to roll back the transaction, it should do so
- * by raising an appropriate <code>XAException</code> in the prepare method.
+ * @return A value indicating the resource manager's vote on the outcome of the
+ * transaction. The possible values are: XA_RDONLY or XA_OK. If the resource
+ * manager wants to roll back the transaction, it should do so by raising an
+ * appropriate <code>XAException</code> in the prepare method.
*/
public int prepare(Xid xid) throws XAException {
try {
- int result = xar.prepare(xid);
- //When the VOTE from resource manager is XA_RDONLY , we will not get commit() call from TxManager.
- //Hence calling txCompleted.
+ int result = xaResource.prepare(xid);
+ // When the VOTE from resource manager is XA_RDONLY , we will not get commit()
+ // call from TxManager.
+ // Hence calling txCompleted.
if (result == XAResource.XA_RDONLY) {
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
}
return result;
} catch (XAException xae) {
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
throw xae;
} catch (Exception e) {
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
throw new XAException(e.getMessage());
}
}
@@ -144,59 +143,61 @@
/**
* Obtain a list of prepared transaction branches from a resource manager.
*
- * @param flag One of TMSTARTRSCAN, TMENDRSCAN, TMNOFLAGS. TMNOFLAGS
- * must be used when no other flags are set in flags.
+ * @param flag One of TMSTARTRSCAN, TMENDRSCAN, TMNOFLAGS. TMNOFLAGS must be
+ * used when no other flags are set in flags.
* @return The resource manager returns zero or more XIDs for the transaction
- * branches that are currently in a prepared or heuristically
- * completed state. If an error occurs during the operation, the resource
- * manager should throw the appropriate <code>XAException</code>.
+ * branches that are currently in a prepared or heuristically completed state.
+ * If an error occurs during the operation, the resource manager should throw
+ * the appropriate <code>XAException</code>.
*/
public Xid[] recover(int flag) throws XAException {
- return xar.recover(flag);
+ return xaResource.recover(flag);
}
/**
- * Inform the resource manager to roll back work done on behalf of a transaction branch
+ * Inform the resource manager to roll back work done on behalf of a transaction
+ * branch
*
* @param xid A global transaction identifier
*/
public void rollback(Xid xid) throws XAException {
- //the mc.transactionCompleted call has come here becasue
- //the transaction *actually* completes after the flow
- //reaches here. the end() method might not really signal
- //completion of transaction in case the transaction is
- //suspended. In case of transaction suspension, the end
- //method is still called by the transaction manager
+ // the mc.transactionCompleted call has come here becasue
+ // the transaction *actually* completes after the flow
+ // reaches here. the end() method might not really signal
+ // completion of transaction in case the transaction is
+ // suspended. In case of transaction suspension, the end
+ // method is still called by the transaction manager
try {
- xar.rollback(xid);
+ xaResource.rollback(xid);
} catch (XAException xae) {
throw xae;
} catch (Exception e) {
throw new XAException(e.getMessage());
} finally {
- mc.transactionCompleted();
+ managedConnectionImpl.transactionCompleted();
}
}
/**
- * Set the current transaction timeout value for this <code>XAResource</code> instance.
+ * Set the current transaction timeout value for this <code>XAResource</code>
+ * instance.
*
* @param seconds the transaction timeout value in seconds.
- * @return true if transaction timeout value is set successfully; otherwise false.
+ * @return true if transaction timeout value is set successfully; otherwise
+ * false.
*/
public boolean setTransactionTimeout(int seconds) throws XAException {
- return xar.setTransactionTimeout(seconds);
+ return xaResource.setTransactionTimeout(seconds);
}
/**
* Start work on behalf of a transaction branch specified in xid.
*
* @param xid A global transaction identifier to be associated with the resource
- * @return flags One of TMNOFLAGS, TMJOIN, or TMRESUME
+ * @return flags One of TMNOFLAGS, TMJOIN, or TMRESUME
*/
public void start(Xid xid, int flags) throws XAException {
- //GJCINT
- mc.transactionStarted();
- xar.start(xid, flags);
+ managedConnectionImpl.transactionStarted();
+ xaResource.start(xid, flags);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/AbstractDataSource.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/AbstractDataSource.java
index 8391c6e..101c412 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/AbstractDataSource.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/AbstractDataSource.java
@@ -16,36 +16,45 @@
package com.sun.gjc.spi.base;
+import static java.util.logging.Level.WARNING;
+
+import java.io.PrintWriter;
+import java.io.Serializable;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+import javax.naming.Reference;
+import javax.sql.DataSource;
+
+import com.sun.appserv.connectors.internal.api.ConnectorConstants;
import com.sun.appserv.connectors.internal.spi.BadConnectionEventListener;
import com.sun.gjc.spi.ConnectionManagerImplementation;
import com.sun.gjc.spi.ConnectionRequestInfoImpl;
import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
-import com.sun.logging.LogDomains;
-import com.sun.appserv.connectors.internal.api.ConnectorConstants;
import com.sun.gjc.util.MethodExecutor;
+import com.sun.logging.LogDomains;
-import javax.naming.Reference;
+import jakarta.resource.Referenceable;
import jakarta.resource.ResourceException;
import jakarta.resource.spi.ConnectionManager;
-import java.io.PrintWriter;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
- * Holds the <code>java.sql.Connection</code> object, which is to be
- * passed to the application program.
+ * Holds the <code>java.sql.Connection</code> object, which is to be passed to
+ * the application program.
*
* @author Binod P.G
* @version 1.0, 02/07/31
*/
-public abstract class AbstractDataSource implements javax.sql.DataSource, java.io.Serializable,
- com.sun.appserv.jdbc.DataSource, jakarta.resource.Referenceable {
+public abstract class AbstractDataSource implements DataSource, Serializable, com.sun.appserv.jdbc.DataSource, Referenceable {
- protected ManagedConnectionFactoryImpl mcf;
- protected MethodExecutor executor = null;
- private ConnectionManager cm;
+ private static final long serialVersionUID = 1L;
+
+ protected final static Logger _logger = LogDomains.getLogger(ManagedConnectionFactoryImpl.class, LogDomains.RSR_LOGGER);
+
+ protected ManagedConnectionFactoryImpl managedConnectionFactoryImpl;
+ protected MethodExecutor executor;
+ private ConnectionManager connectionManager;
private int loginTimeout;
private PrintWriter logWriter;
private String description;
@@ -53,28 +62,22 @@
private ConnectionHolder.ConnectionType conType_;
- protected final static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(ManagedConnectionFactoryImpl.class, LogDomains.RSR_LOGGER);
- }
/**
* Constructs <code>DataSource</code> object. This is created by the
* <code>ManagedConnectionFactory</code> object.
*
- * @param mcf <code>ManagedConnectionFactory</code> object
- * creating this object.
- * @param cm <code>ConnectionManager</code> object either associated
- * with Application server or Resource Adapter.
+ * @param managedConnectionFactoryImpl <code>ManagedConnectionFactory</code> object creating this object.
+ * @param connectionManager <code>ConnectionManager</code> object either associated with
+ * Application server or Resource Adapter.
*/
- public AbstractDataSource(ManagedConnectionFactoryImpl mcf, ConnectionManager cm) {
- this.mcf = mcf;
+ public AbstractDataSource(ManagedConnectionFactoryImpl managedConnectionFactoryImpl, ConnectionManager connectionManager) {
+ this.managedConnectionFactoryImpl = managedConnectionFactoryImpl;
executor = new MethodExecutor();
- if (cm == null) {
- this.cm = new ConnectionManagerImplementation();
+ if (connectionManager == null) {
+ this.connectionManager = new ConnectionManagerImplementation();
} else {
- this.cm = cm;
+ this.connectionManager = connectionManager;
conType_ = findConnectionType();
}
}
@@ -87,11 +90,10 @@
*/
public Connection getConnection() throws SQLException {
try {
- ConnectionHolder con = (ConnectionHolder)
- cm.allocateConnection(mcf, null);
- setConnectionType(con);
+ ConnectionHolder connection = (ConnectionHolder) connectionManager.allocateConnection(managedConnectionFactoryImpl, null);
+ setConnectionType(connection);
- return con;
+ return connection;
} catch (ResourceException re) {
logNonTransientException(re);
throw new SQLException(re.getMessage(), re);
@@ -100,11 +102,12 @@
/**
* log the exception if it is a non-transient exception <br>
+ *
* @param re Exception to log
*/
private void logNonTransientException(ResourceException re) {
- if(!BadConnectionEventListener.POOL_RECONFIGURED_ERROR_CODE.equals(re.getErrorCode())){
- _logger.log(Level.WARNING, "jdbc.exc_get_conn", re.getMessage());
+ if (!BadConnectionEventListener.POOL_RECONFIGURED_ERROR_CODE.equals(re.getErrorCode())) {
+ _logger.log(WARNING, "jdbc.exc_get_conn", re.getMessage());
}
}
@@ -112,15 +115,14 @@
* Retrieves the <code> Connection </code> object.
*
* @param user User name for the Connection.
- * @param pwd Password for the Connection.
+ * @param pwd Password for the Connection.
* @return <code> Connection </code> object.
* @throws SQLException In case of an error.
*/
public Connection getConnection(String user, String pwd) throws SQLException {
try {
ConnectionRequestInfoImpl info = new ConnectionRequestInfoImpl(user, pwd.toCharArray());
- ConnectionHolder con = (ConnectionHolder)
- cm.allocateConnection(mcf, info);
+ ConnectionHolder con = (ConnectionHolder) connectionManager.allocateConnection(managedConnectionFactoryImpl, info);
setConnectionType(con);
return con;
} catch (ResourceException re) {
@@ -130,14 +132,13 @@
}
/**
- * Retrieves the actual SQLConnection from the Connection wrapper
- * implementation of SunONE application server. If an actual connection is
- * supplied as argument, then it will be just returned.
+ * Retrieves the actual SQLConnection from the Connection wrapper implementation
+ * of SunONE application server. If an actual connection is supplied as
+ * argument, then it will be just returned.
*
* @param con Connection obtained from <code>Datasource.getConnection()</code>
* @return <code>java.sql.Connection</code> implementation of the driver.
- * @throws <code>java.sql.SQLException</code>
- * If connection cannot be obtained.
+ * @throws <code>java.sql.SQLException</code> If connection cannot be obtained.
*/
public Connection getConnection(Connection con) throws SQLException {
@@ -150,24 +151,22 @@
}
/**
- * Gets a connection that is not in the scope of any transaction. This
- * can be used to save performance overhead incurred on enlisting/delisting
- * each connection got, irrespective of whether its required or not.
- * Note here that this meethod does not fit in the connector contract
- * per se.
+ * Gets a connection that is not in the scope of any transaction. This can be
+ * used to save performance overhead incurred on enlisting/delisting each
+ * connection got, irrespective of whether its required or not. Note here that
+ * this meethod does not fit in the connector contract per se.
*
* @return <code>java.sql.Connection</code>
- * @throws <code>java.sql.SQLException</code>
- * If connection cannot be obtained
+ * @throws <code>java.sql.SQLException</code> If connection cannot be obtained
*/
public Connection getNonTxConnection() throws SQLException {
try {
- ConnectionHolder con = (ConnectionHolder)
- ((com.sun.appserv.connectors.internal.spi.ConnectionManager)
- cm).allocateNonTxConnection(mcf, null);
- setConnectionType(con, true);
+ ConnectionHolder connection =
+ (ConnectionHolder) ((com.sun.appserv.connectors.internal.spi.ConnectionManager) connectionManager)
+ .allocateNonTxConnection(managedConnectionFactoryImpl, null);
+ setConnectionType(connection, true);
- return con;
+ return connection;
} catch (ResourceException re) {
logNonTransientException(re);
throw new SQLException(re.getMessage(), re);
@@ -175,24 +174,21 @@
}
/**
- * Gets a connection that is not in the scope of any transaction. This
- * can be used to save performance overhead incurred on enlisting/delisting
- * each connection got, irrespective of whether its required or not.
- * Note here that this meethod does not fit in the connector contract
- * per se.
+ * Gets a connection that is not in the scope of any transaction. This can be
+ * used to save performance overhead incurred on enlisting/delisting each
+ * connection got, irrespective of whether its required or not. Note here that
+ * this meethod does not fit in the connector contract per se.
*
- * @param user User name for authenticating the connection
+ * @param user User name for authenticating the connection
* @param password Password for authenticating the connection
* @return <code>java.sql.Connection</code>
- * @throws <code>java.sql.SQLException</code>
- * If connection cannot be obtained
+ * @throws <code>java.sql.SQLException</code> If connection cannot be obtained
*/
public Connection getNonTxConnection(String user, String password) throws SQLException {
try {
ConnectionRequestInfoImpl cxReqInfo = new ConnectionRequestInfoImpl(user, password.toCharArray());
- ConnectionHolder con = (ConnectionHolder)
- ((com.sun.appserv.connectors.internal.spi.ConnectionManager)
- cm).allocateNonTxConnection(mcf, cxReqInfo);
+ ConnectionHolder con = (ConnectionHolder) ((com.sun.appserv.connectors.internal.spi.ConnectionManager) connectionManager)
+ .allocateNonTxConnection(managedConnectionFactoryImpl, cxReqInfo);
setConnectionType(con, true);
@@ -282,17 +278,16 @@
private ConnectionHolder.ConnectionType findConnectionType() {
ConnectionHolder.ConnectionType cmType = ConnectionHolder.ConnectionType.STANDARD;
- if (cm instanceof jakarta.resource.spi.LazyAssociatableConnectionManager) {
- if (!((com.sun.appserv.connectors.internal.spi.ConnectionManager) cm).
- getJndiName().endsWith(ConnectorConstants.PM_JNDI_SUFFIX)) {
+ if (connectionManager instanceof jakarta.resource.spi.LazyAssociatableConnectionManager) {
+ if (!((com.sun.appserv.connectors.internal.spi.ConnectionManager) connectionManager).getJndiName()
+ .endsWith(ConnectorConstants.PM_JNDI_SUFFIX)) {
cmType = ConnectionHolder.ConnectionType.LAZY_ASSOCIATABLE;
}
- } else if (cm instanceof
- jakarta.resource.spi.LazyEnlistableConnectionManager) {
- if (!((com.sun.appserv.connectors.internal.spi.ConnectionManager) cm).
- getJndiName().endsWith(ConnectorConstants.PM_JNDI_SUFFIX) &&
- !((com.sun.appserv.connectors.internal.spi.ConnectionManager) cm).
- getJndiName().endsWith(ConnectorConstants.NON_TX_JNDI_SUFFIX)) {
+ } else if (connectionManager instanceof jakarta.resource.spi.LazyEnlistableConnectionManager) {
+ if (!((com.sun.appserv.connectors.internal.spi.ConnectionManager) connectionManager).getJndiName()
+ .endsWith(ConnectorConstants.PM_JNDI_SUFFIX)
+ && !((com.sun.appserv.connectors.internal.spi.ConnectionManager) connectionManager).getJndiName()
+ .endsWith(ConnectorConstants.NON_TX_JNDI_SUFFIX)) {
cmType = ConnectionHolder.ConnectionType.LAZY_ENLISTABLE;
}
}
@@ -306,27 +301,26 @@
private void setConnectionType(ConnectionHolder con, boolean isNonTx) {
con.setConnectionType(conType_);
- if (conType_ == ConnectionHolder.ConnectionType.LAZY_ASSOCIATABLE &&
- cm instanceof jakarta.resource.spi.LazyAssociatableConnectionManager) {
- con.setLazyAssociatableConnectionManager(
- (jakarta.resource.spi.LazyAssociatableConnectionManager) cm);
+ if (conType_ == ConnectionHolder.ConnectionType.LAZY_ASSOCIATABLE
+ && connectionManager instanceof jakarta.resource.spi.LazyAssociatableConnectionManager) {
+ con.setLazyAssociatableConnectionManager((jakarta.resource.spi.LazyAssociatableConnectionManager) connectionManager);
} else if (conType_ == ConnectionHolder.ConnectionType.LAZY_ENLISTABLE) {
if (isNonTx) {
- //if this is a getNonTxConnection call on the DataSource, we
- //should not LazyEnlist
+ // if this is a getNonTxConnection call on the DataSource, we
+ // should not LazyEnlist
con.setConnectionType(ConnectionHolder.ConnectionType.STANDARD);
- } else if(cm instanceof jakarta.resource.spi.LazyEnlistableConnectionManager) {
- con.setLazyEnlistableConnectionManager(
- (jakarta.resource.spi.LazyEnlistableConnectionManager) cm);
+ } else if (connectionManager instanceof jakarta.resource.spi.LazyEnlistableConnectionManager) {
+ con.setLazyEnlistableConnectionManager((jakarta.resource.spi.LazyEnlistableConnectionManager) connectionManager);
}
}
}
/**
- * API to mark a connection as bad. If the application can determine that the connection
- * is bad, using this api, it can notify the resource-adapter which inturn will notify the
- * connection-pool. Connection-pool will drop and create a new connection.
- * eg:
+ * API to mark a connection as bad. If the application can determine that the
+ * connection is bad, using this api, it can notify the resource-adapter which
+ * inturn will notify the connection-pool. Connection-pool will drop and create
+ * a new connection. eg:
+ *
* <pre>
com.sun.appserv.jdbc.DataSource ds=
(com.sun.appserv.jdbc.DataSource)context.lookup("dataSource");
@@ -343,12 +337,12 @@
}
* </pre>
*
- * @param conn <code>java.sql.Connection</code>
+ * @param connection <code>java.sql.Connection</code>
*/
- public void markConnectionAsBad(Connection conn) {
- if (conn instanceof ConnectionHolder) {
- ConnectionHolder userConn = ((ConnectionHolder) conn);
- userConn.getManagedConnection().markForRemoval(true);
+ public void markConnectionAsBad(Connection connection) {
+ if (connection instanceof ConnectionHolder) {
+ ConnectionHolder userConnection = ((ConnectionHolder) connection);
+ userConnection.getManagedConnection().markForRemoval(true);
}
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CacheObjectKey.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CacheObjectKey.java
index 3aa5234..2fc5d7f 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CacheObjectKey.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CacheObjectKey.java
@@ -26,8 +26,8 @@
public static final String CALLABLE_STATEMENT = "CS";
public static final String PREPARED_STATEMENT = "PS";
- protected String sql = null;
- protected String statementType = null;
+ protected String sql;
+ protected String statementType;
protected int resultSetType;
protected int resultSetConcurrency;
protected int resultSetHoldability;
@@ -71,16 +71,14 @@
this.columnIndexes = columnIndexes;
}
- public CacheObjectKey(String sql, String statementType,
- int resultSetType, int resultSetConcurrency) {
+ public CacheObjectKey(String sql, String statementType, int resultSetType, int resultSetConcurrency) {
this.sql = sql;
this.statementType = statementType;
this.resultSetType = resultSetType;
this.resultSetConcurrency = resultSetConcurrency;
}
- public CacheObjectKey(String sql, String statementType,
- int resultSetType, int resultSetConcurrency,
+ public CacheObjectKey(String sql, String statementType, int resultSetType, int resultSetConcurrency,
int resultSetHoldability) {
this.sql = sql;
this.statementType = statementType;
@@ -89,22 +87,19 @@
this.resultSetHoldability = resultSetHoldability;
}
- public CacheObjectKey(String sql, String statementType,
- int[] columnIndexes) {
+ public CacheObjectKey(String sql, String statementType, int[] columnIndexes) {
this.sql = sql;
this.statementType = statementType;
this.columnIndexes = columnIndexes;
}
- public CacheObjectKey(String sql, String statementType,
- String[] columnNames) {
+ public CacheObjectKey(String sql, String statementType, String[] columnNames) {
this.sql = sql;
this.statementType = statementType;
this.columnNames = columnNames;
}
- public CacheObjectKey(String sql, String statementType,
- int autoGeneratedKeys) {
+ public CacheObjectKey(String sql, String statementType, int autoGeneratedKeys) {
this.sql = sql;
this.statementType = statementType;
this.autoGeneratedKeys = autoGeneratedKeys;
@@ -153,6 +148,7 @@
public void setResultSetType(int resultSetType) {
this.resultSetType = resultSetType;
}
+
/**
* Get the value of resultSetHoldability
*
@@ -175,86 +171,6 @@
}
/**
- * Check for the equality of the CacheObjectKey with the object passed by
- * 1. comparing the sql string values
- * 2. comparing the statement type values
- * 3. comapring the getClass() values
- * @param obj obj which is to be checked against this object
- * @return boolean
- */
- @Override
- public boolean equals(Object obj) {
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- final CacheObjectKey other = (CacheObjectKey) obj;
- if (this.sql == null || other.sql == null || !this.sql.equals(other.sql)) {
- return false;
- }
- if (this.statementType == null || other.statementType == null ||
- !this.statementType.equals(other.statementType)) {
- return false;
- }
- if (this.resultSetType != other.resultSetType) {
- return false;
- }
- if (this.resultSetConcurrency != other.resultSetConcurrency) {
- return false;
- }
- if (this.resultSetHoldability != other.resultSetHoldability) {
- return false;
- }
- if(CacheObjectKey.PREPARED_STATEMENT.equals(other.statementType)) {
- if (this.autoGeneratedKeys != other.autoGeneratedKeys) {
- return false;
- }
- //Iterate through the columnNames/columnIndexes to see if equal
- if(this.columnIndexes != null && other.columnIndexes != null) {
- if (!Arrays.equals(this.columnIndexes, other.columnIndexes)) {
- return false;
- }
- }
- if(this.columnNames != null && other.columnNames != null) {
- if(!Arrays.equals(this.columnNames, other.columnNames)) {
- return false;
- }
- }
- }
- return true;
- }
-
- /**
- * Generate hashCode for this object using the sql and statementType fields
- * @return has integer value
- */
- @Override
- public int hashCode() {
- int hash = 7;
- hash = 41 * hash + (this.sql != null ? this.sql.hashCode() : 0);
- hash = 41 * hash + (this.statementType != null ? this.statementType.hashCode() : 0);
- hash = 41 * hash + this.resultSetType;
- hash = 41 * hash + this.resultSetConcurrency;
- hash = 41 * hash + this.resultSetHoldability;
- if(CacheObjectKey.PREPARED_STATEMENT.equals(this.statementType)) {
- hash = 41 * hash + this.autoGeneratedKeys;
- if(this.columnIndexes != null) {
- for(int i : this.columnIndexes) {
- hash = 41 * hash + ((Integer) i).hashCode();
- }
- }
- if(this.columnNames != null) {
- for(String str : columnNames) {
- hash = 41 * hash + str.hashCode();
- }
- }
- }
- return hash;
- }
-
- /**
* Get the value of statementType
*
* @return the value of statementType
@@ -289,4 +205,85 @@
public void setSql(String sql) {
this.sql = sql;
}
+
+ /**
+ * Check for the equality of the CacheObjectKey with the object passed by 1.
+ * comparing the sql string values 2. comparing the statement type values 3.
+ * comapring the getClass() values
+ *
+ * @param obj obj which is to be checked against this object
+ * @return boolean
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null) {
+ return false;
+ }
+ if (getClass() != obj.getClass()) {
+ return false;
+ }
+ final CacheObjectKey other = (CacheObjectKey) obj;
+ if (this.sql == null || other.sql == null || !this.sql.equals(other.sql)) {
+ return false;
+ }
+ if (this.statementType == null || other.statementType == null
+ || !this.statementType.equals(other.statementType)) {
+ return false;
+ }
+ if (this.resultSetType != other.resultSetType) {
+ return false;
+ }
+ if (this.resultSetConcurrency != other.resultSetConcurrency) {
+ return false;
+ }
+ if (this.resultSetHoldability != other.resultSetHoldability) {
+ return false;
+ }
+ if (CacheObjectKey.PREPARED_STATEMENT.equals(other.statementType)) {
+ if (this.autoGeneratedKeys != other.autoGeneratedKeys) {
+ return false;
+ }
+ // Iterate through the columnNames/columnIndexes to see if equal
+ if (this.columnIndexes != null && other.columnIndexes != null) {
+ if (!Arrays.equals(this.columnIndexes, other.columnIndexes)) {
+ return false;
+ }
+ }
+ if (this.columnNames != null && other.columnNames != null) {
+ if (!Arrays.equals(this.columnNames, other.columnNames)) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Generate hashCode for this object using the sql and statementType fields
+ *
+ * @return has integer value
+ */
+ @Override
+ public int hashCode() {
+ int hash = 7;
+ hash = 41 * hash + (this.sql != null ? this.sql.hashCode() : 0);
+ hash = 41 * hash + (this.statementType != null ? this.statementType.hashCode() : 0);
+ hash = 41 * hash + this.resultSetType;
+ hash = 41 * hash + this.resultSetConcurrency;
+ hash = 41 * hash + this.resultSetHoldability;
+ if (CacheObjectKey.PREPARED_STATEMENT.equals(this.statementType)) {
+ hash = 41 * hash + this.autoGeneratedKeys;
+ if (this.columnIndexes != null) {
+ for (int i : this.columnIndexes) {
+ hash = 41 * hash + ((Integer) i).hashCode();
+ }
+ }
+ if (this.columnNames != null) {
+ for (String str : columnNames) {
+ hash = 41 * hash + str.hashCode();
+ }
+ }
+ }
+ return hash;
+ }
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CallableStatementWrapper.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CallableStatementWrapper.java
index f09dc06..3b9a808 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CallableStatementWrapper.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/CallableStatementWrapper.java
@@ -20,51 +20,56 @@
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
-import java.sql.*;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;
-
/**
* Abstract class for wrapping PreparedStatement<br>
*/
public abstract class CallableStatementWrapper extends PreparedStatementWrapper implements CallableStatement {
- protected CallableStatement callableStatement = null;
+
+ protected CallableStatement callableStatement;
/**
* Creates a new instance of CallableStatementWrapper<br>
*
- * @param con ConnectionWrapper <br>
+ * @param con ConnectionWrapper <br>
* @param statement Statement that is to be wrapped<br>
*/
- public CallableStatementWrapper(Connection con, CallableStatement statement,
- boolean cachingEnabled) throws SQLException{
+ public CallableStatementWrapper(Connection con, CallableStatement statement, boolean cachingEnabled) throws SQLException {
super(con, statement, cachingEnabled);
callableStatement = statement;
}
/**
- * Registers the OUT parameter in ordinal position
- * <code>parameterIndex</code> to the JDBC type
- * <code>sqlType</code>. All OUT parameters must be registered
+ * Registers the OUT parameter in ordinal position <code>parameterIndex</code>
+ * to the JDBC type <code>sqlType</code>. All OUT parameters must be registered
* before a stored procedure is executed.
* <p/>
- * The JDBC type specified by <code>sqlType</code> for an OUT
- * parameter determines the Java type that must be used
- * in the <code>get</code> method to read the value of that parameter.
+ * The JDBC type specified by <code>sqlType</code> for an OUT parameter
+ * determines the Java type that must be used in the <code>get</code> method to
+ * read the value of that parameter.
* <p/>
- * If the JDBC type expected to be returned to this output parameter
- * is specific to this particular database, <code>sqlType</code>
- * should be <code>java.sql.Types.OTHER</code>. The method
- * {@link #getObject} retrieves the value.
+ * If the JDBC type expected to be returned to this output parameter is specific
+ * to this particular database, <code>sqlType</code> should be
+ * <code>java.sql.Types.OTHER</code>. The method {@link #getObject} retrieves
+ * the value.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.
- * If the parameter is of JDBC type <code>NUMERIC</code>
- * or <code>DECIMAL</code>, the version of
- * <code>registerOutParameter</code> that accepts a scale value
- * should be used.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>. If
+ * the parameter is of JDBC type <code>NUMERIC</code> or <code>DECIMAL</code>,
+ * the version of <code>registerOutParameter</code> that accepts a scale value
+ * should be used.
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
*/
@@ -73,24 +78,21 @@
}
/**
- * Registers the parameter in ordinal position
- * <code>parameterIndex</code> to be of JDBC type
- * <code>sqlType</code>. This method must be called
- * before a stored procedure is executed.
+ * Registers the parameter in ordinal position <code>parameterIndex</code> to be
+ * of JDBC type <code>sqlType</code>. This method must be called before a stored
+ * procedure is executed.
* <p/>
- * The JDBC type specified by <code>sqlType</code> for an OUT
- * parameter determines the Java type that must be used
- * in the <code>get</code> method to read the value of that parameter.
+ * The JDBC type specified by <code>sqlType</code> for an OUT parameter
+ * determines the Java type that must be used in the <code>get</code> method to
+ * read the value of that parameter.
* <p/>
- * This version of <code>registerOutParameter</code> should be
- * used when the parameter is of JDBC type <code>NUMERIC</code>
- * or <code>DECIMAL</code>.
+ * This version of <code>registerOutParameter</code> should be used when the
+ * parameter is of JDBC type <code>NUMERIC</code> or <code>DECIMAL</code>.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @param sqlType the SQL type code defined by <code>java.sql.Types</code>.
- * @param scale the desired number of digits to the right of the
- * decimal point. It must be greater than or equal to zero.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @param sqlType the SQL type code defined by <code>java.sql.Types</code>.
+ * @param scale the desired number of digits to the right of the decimal point.
+ * It must be greater than or equal to zero.
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
*/
@@ -99,13 +101,13 @@
}
/**
- * Retrieves whether the last OUT parameter read had the value of
- * SQL <code>NULL</code>. Note that this method should be called only after
- * calling a getter method; otherwise, there is no value to use in
- * determining whether it is <code>null</code> or not.
+ * Retrieves whether the last OUT parameter read had the value of SQL
+ * <code>NULL</code>. Note that this method should be called only after calling
+ * a getter method; otherwise, there is no value to use in determining whether
+ * it is <code>null</code> or not.
*
* @return <code>true</code> if the last parameter read was SQL
- * <code>NULL</code>; <code>false</code> otherwise
+ * <code>NULL</code>; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean wasNull() throws SQLException {
@@ -117,17 +119,13 @@
* <code>VARCHAR</code>, or <code>LONGVARCHAR</code> parameter as a
* <code>String</code> in the Java programming language.
* <p/>
- * For the fixed-length type JDBC <code>CHAR</code>,
- * the <code>String</code> object
- * returned has exactly the same value the JDBC
- * <code>CHAR</code> value had in the
- * database, including any padding added by the database.
+ * For the fixed-length type JDBC <code>CHAR</code>, the <code>String</code>
+ * object returned has exactly the same value the JDBC <code>CHAR</code> value
+ * had in the database, including any padding added by the database.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setString
*/
@@ -139,10 +137,9 @@
* Retrieves the value of the designated JDBC <code>BIT</code> parameter as a
* <code>boolean</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result is <code>false</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>false</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBoolean
*/
@@ -151,13 +148,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>TINYINT</code> parameter
- * as a <code>byte</code> in the Java programming language.
+ * Retrieves the value of the designated JDBC <code>TINYINT</code> parameter as
+ * a <code>byte</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setByte
*/
@@ -166,13 +162,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>SMALLINT</code> parameter
- * as a <code>short</code> in the Java programming language.
+ * Retrieves the value of the designated JDBC <code>SMALLINT</code> parameter as
+ * a <code>short</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setShort
*/
@@ -181,13 +176,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>INTEGER</code> parameter
- * as an <code>int</code> in the Java programming language.
+ * Retrieves the value of the designated JDBC <code>INTEGER</code> parameter as
+ * an <code>int</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setInt
*/
@@ -196,13 +190,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>BIGINT</code> parameter
- * as a <code>long</code> in the Java programming language.
+ * Retrieves the value of the designated JDBC <code>BIGINT</code> parameter as a
+ * <code>long</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setLong
*/
@@ -211,13 +204,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>FLOAT</code> parameter
- * as a <code>float</code> in the Java programming language.
+ * Retrieves the value of the designated JDBC <code>FLOAT</code> parameter as a
+ * <code>float</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setFloat
*/
@@ -226,13 +218,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>DOUBLE</code> parameter as a <code>double</code>
- * in the Java programming language.
+ * Retrieves the value of the designated JDBC <code>DOUBLE</code> parameter as a
+ * <code>double</code> in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setDouble
*/
@@ -241,19 +232,18 @@
}
/**
- * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as a
- * <code>java.math.BigDecimal</code> object with <i>scale</i> digits to
- * the right of the decimal point.
+ * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as
+ * a <code>java.math.BigDecimal</code> object with <i>scale</i> digits to the
+ * right of the decimal point.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @param scale the number of digits to the right of the decimal point
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @param scale the number of digits to the right of the decimal point
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBigDecimal
- * @deprecated use <code>getBigDecimal(int parameterIndex)</code>
- * or <code>getBigDecimal(String parameterName)</code>
+ * @deprecated use <code>getBigDecimal(int parameterIndex)</code> or
+ * <code>getBigDecimal(String parameterName)</code>
*/
@Deprecated
public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException {
@@ -262,13 +252,12 @@
/**
* Retrieves the value of the designated JDBC <code>BINARY</code> or
- * <code>VARBINARY</code> parameter as an array of <code>byte</code>
- * values in the Java programming language.
+ * <code>VARBINARY</code> parameter as an array of <code>byte</code> values in
+ * the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBytes
*/
@@ -280,10 +269,9 @@
* Retrieves the value of the designated JDBC <code>DATE</code> parameter as a
* <code>java.sql.Date</code> object.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setDate
*/
@@ -295,10 +283,9 @@
* Retrieves the value of the designated JDBC <code>TIME</code> parameter as a
* <code>java.sql.Time</code> object.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTime
*/
@@ -307,13 +294,12 @@
}
/**
- * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter as a
- * <code>java.sql.Timestamp</code> object.
+ * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter
+ * as a <code>java.sql.Timestamp</code> object.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTimestamp
*/
@@ -322,18 +308,17 @@
}
/**
- * Retrieves the value of the designated parameter as an <code>Object</code>
- * in the Java programming language. If the value is an SQL <code>NULL</code>,
- * the driver returns a Java <code>null</code>.
+ * Retrieves the value of the designated parameter as an <code>Object</code> in
+ * the Java programming language. If the value is an SQL <code>NULL</code>, the
+ * driver returns a Java <code>null</code>.
* <p/>
- * This method returns a Java object whose type corresponds to the JDBC
- * type that was registered for this parameter using the method
- * <code>registerOutParameter</code>. By registering the target JDBC
- * type as <code>java.sql.Types.OTHER</code>, this method can be used
- * to read database-specific abstract data types.
+ * This method returns a Java object whose type corresponds to the JDBC type
+ * that was registered for this parameter using the method
+ * <code>registerOutParameter</code>. By registering the target JDBC type as
+ * <code>java.sql.Types.OTHER</code>, this method can be used to read
+ * database-specific abstract data types.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
* @return A <code>java.lang.Object</code> holding the OUT parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
@@ -344,14 +329,13 @@
}
/**
- * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as a
- * <code>java.math.BigDecimal</code> object with as many digits to the
- * right of the decimal point as the value contains.
+ * Retrieves the value of the designated JDBC <code>NUMERIC</code> parameter as
+ * a <code>java.math.BigDecimal</code> object with as many digits to the right
+ * of the decimal point as the value contains.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value in full precision. If the value is
- * SQL <code>NULL</code>, the result is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value in full precision. If the value is SQL
+ * <code>NULL</code>, the result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBigDecimal
* @since 1.2
@@ -361,14 +345,14 @@
}
/**
- * Retrieves the value of the designated JDBC <code>REF(<structured-type>)</code>
- * parameter as a {@link java.sql.Ref} object in the Java programming language.
+ * Retrieves the value of the designated JDBC
+ * <code>REF(<structured-type>)</code> parameter as a {@link java.sql.Ref}
+ * object in the Java programming language.
*
- * @param i the first parameter is 1, the second is 2,
- * and so on
- * @return the parameter value as a <code>Ref</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>, the value
- * <code>null</code> is returned.
+ * @param i the first parameter is 1, the second is 2, and so on
+ * @return the parameter value as a <code>Ref</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -381,9 +365,9 @@
* {@link java.sql.Blob} object in the Java programming language.
*
* @param i the first parameter is 1, the second is 2, and so on
- * @return the parameter value as a <code>Blob</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>, the value
- * <code>null</code> is returned.
+ * @return the parameter value as a <code>Blob</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -395,11 +379,10 @@
* Retrieves the value of the designated JDBC <code>CLOB</code> parameter as a
* <code>Clob</code> object in the Java programming language.
*
- * @param i the first parameter is 1, the second is 2, and
- * so on
- * @return the parameter value as a <code>Clob</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>, the
- * value <code>null</code> is returned.
+ * @param i the first parameter is 1, the second is 2, and so on
+ * @return the parameter value as a <code>Clob</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -411,11 +394,10 @@
* Retrieves the value of the designated JDBC <code>ARRAY</code> parameter as an
* {@link java.sql.Array} object in the Java programming language.
*
- * @param i the first parameter is 1, the second is 2, and
- * so on
- * @return the parameter value as an <code>Array</code> object in
- * the Java programming language. If the value was SQL <code>NULL</code>, the
- * value <code>null</code> is returned.
+ * @param i the first parameter is 1, the second is 2, and so on
+ * @return the parameter value as an <code>Array</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -425,20 +407,17 @@
/**
* Retrieves the value of the designated JDBC <code>DATE</code> parameter as a
- * <code>java.sql.Date</code> object, using
- * the given <code>Calendar</code> object
- * to construct the date.
- * With a <code>Calendar</code> object, the driver
- * can calculate the date taking into account a custom timezone and locale.
- * If no <code>Calendar</code> object is specified, the driver uses the
- * default timezone and locale.
+ * <code>java.sql.Date</code> object, using the given <code>Calendar</code>
+ * object to construct the date. With a <code>Calendar</code> object, the driver
+ * can calculate the date taking into account a custom timezone and locale. If
+ * no <code>Calendar</code> object is specified, the driver uses the default
+ * timezone and locale.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the date
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the date
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setDate
* @since 1.2
@@ -449,20 +428,17 @@
/**
* Retrieves the value of the designated JDBC <code>TIME</code> parameter as a
- * <code>java.sql.Time</code> object, using
- * the given <code>Calendar</code> object
- * to construct the time.
- * With a <code>Calendar</code> object, the driver
- * can calculate the time taking into account a custom timezone and locale.
- * If no <code>Calendar</code> object is specified, the driver uses the
- * default timezone and locale.
+ * <code>java.sql.Time</code> object, using the given <code>Calendar</code>
+ * object to construct the time. With a <code>Calendar</code> object, the driver
+ * can calculate the time taking into account a custom timezone and locale. If
+ * no <code>Calendar</code> object is specified, the driver uses the default
+ * timezone and locale.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the time
- * @return the parameter value; if the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the time
+ * @return the parameter value; if the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTime
* @since 1.2
@@ -472,21 +448,18 @@
}
/**
- * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter as a
- * <code>java.sql.Timestamp</code> object, using
- * the given <code>Calendar</code> object to construct
- * the <code>Timestamp</code> object.
- * With a <code>Calendar</code> object, the driver
- * can calculate the timestamp taking into account a custom timezone and locale.
- * If no <code>Calendar</code> object is specified, the driver uses the
- * default timezone and locale.
+ * Retrieves the value of the designated JDBC <code>TIMESTAMP</code> parameter
+ * as a <code>java.sql.Timestamp</code> object, using the given
+ * <code>Calendar</code> object to construct the <code>Timestamp</code> object.
+ * With a <code>Calendar</code> object, the driver can calculate the timestamp
+ * taking into account a custom timezone and locale. If no <code>Calendar</code>
+ * object is specified, the driver uses the default timezone and locale.
*
- * @param parameterIndex the first parameter is 1, the second is 2,
- * and so on
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the timestamp
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the timestamp
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTimestamp
* @since 1.2
@@ -496,35 +469,35 @@
}
/**
- * Registers the designated output parameter. This version of
- * the method <code>registerOutParameter</code>
- * should be used for a user-defined or <code>REF</code> output parameter. Examples
- * of user-defined types include: <code>STRUCT</code>, <code>DISTINCT</code>,
- * <code>JAVA_OBJECT</code>, and named array types.
+ * Registers the designated output parameter. This version of the method
+ * <code>registerOutParameter</code> should be used for a user-defined or
+ * <code>REF</code> output parameter. Examples of user-defined types include:
+ * <code>STRUCT</code>, <code>DISTINCT</code>, <code>JAVA_OBJECT</code>, and
+ * named array types.
* <p/>
- * Before executing a stored procedure call, you must explicitly
- * call <code>registerOutParameter</code> to register the type from
- * <code>java.sql.Types</code> for each
- * OUT parameter. For a user-defined parameter, the fully-qualified SQL
- * type name of the parameter should also be given, while a <code>REF</code>
- * parameter requires that the fully-qualified type name of the
- * referenced type be given. A JDBC driver that does not need the
- * type code and type name information may ignore it. To be portable,
- * however, applications should always provide these values for
- * user-defined and <code>REF</code> parameters.
+ * Before executing a stored procedure call, you must explicitly call
+ * <code>registerOutParameter</code> to register the type from
+ * <code>java.sql.Types</code> for each OUT parameter. For a user-defined
+ * parameter, the fully-qualified SQL type name of the parameter should also be
+ * given, while a <code>REF</code> parameter requires that the fully-qualified
+ * type name of the referenced type be given. A JDBC driver that does not need
+ * the type code and type name information may ignore it. To be portable,
+ * however, applications should always provide these values for user-defined and
+ * <code>REF</code> parameters.
* <p/>
* Although it is intended for user-defined and <code>REF</code> parameters,
- * this method may be used to register a parameter of any JDBC type.
- * If the parameter does not have a user-defined or <code>REF</code> type, the
+ * this method may be used to register a parameter of any JDBC type. If the
+ * parameter does not have a user-defined or <code>REF</code> type, the
* <i>typeName</i> parameter is ignored.
* <p/>
- * <P><B>Note:</B> When reading the value of an out parameter, you
- * must use the getter method whose Java type corresponds to the
- * parameter's registered SQL type.
+ * <P>
+ * <B>Note:</B> When reading the value of an out parameter, you must use the
+ * getter method whose Java type corresponds to the parameter's registered SQL
+ * type.
*
* @param paramIndex the first parameter is 1, the second is 2,...
- * @param sqlType a value from {@link java.sql.Types}
- * @param typeName the fully-qualified name of an SQL structured type
+ * @param sqlType a value from {@link java.sql.Types}
+ * @param typeName the fully-qualified name of an SQL structured type
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
* @since 1.2
@@ -534,26 +507,24 @@
}
/**
- * Registers the OUT parameter named
- * <code>parameterName</code> to the JDBC type
- * <code>sqlType</code>. All OUT parameters must be registered
- * before a stored procedure is executed.
+ * Registers the OUT parameter named <code>parameterName</code> to the JDBC type
+ * <code>sqlType</code>. All OUT parameters must be registered before a stored
+ * procedure is executed.
* <p/>
- * The JDBC type specified by <code>sqlType</code> for an OUT
- * parameter determines the Java type that must be used
- * in the <code>get</code> method to read the value of that parameter.
+ * The JDBC type specified by <code>sqlType</code> for an OUT parameter
+ * determines the Java type that must be used in the <code>get</code> method to
+ * read the value of that parameter.
* <p/>
- * If the JDBC type expected to be returned to this output parameter
- * is specific to this particular database, <code>sqlType</code>
- * should be <code>java.sql.Types.OTHER</code>. The method
- * {@link #getObject} retrieves the value.
+ * If the JDBC type expected to be returned to this output parameter is specific
+ * to this particular database, <code>sqlType</code> should be
+ * <code>java.sql.Types.OTHER</code>. The method {@link #getObject} retrieves
+ * the value.
*
* @param parameterName the name of the parameter
- * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>.
- * If the parameter is of JDBC type <code>NUMERIC</code>
- * or <code>DECIMAL</code>, the version of
- * <code>registerOutParameter</code> that accepts a scale value
- * should be used.
+ * @param sqlType the JDBC type code defined by <code>java.sql.Types</code>. If
+ * the parameter is of JDBC type <code>NUMERIC</code> or <code>DECIMAL</code>,
+ * the version of <code>registerOutParameter</code> that accepts a scale value
+ * should be used.
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
* @since 1.4
@@ -563,23 +534,21 @@
}
/**
- * Registers the parameter named
- * <code>parameterName</code> to be of JDBC type
- * <code>sqlType</code>. This method must be called
- * before a stored procedure is executed.
+ * Registers the parameter named <code>parameterName</code> to be of JDBC type
+ * <code>sqlType</code>. This method must be called before a stored procedure is
+ * executed.
* <p/>
- * The JDBC type specified by <code>sqlType</code> for an OUT
- * parameter determines the Java type that must be used
- * in the <code>get</code> method to read the value of that parameter.
+ * The JDBC type specified by <code>sqlType</code> for an OUT parameter
+ * determines the Java type that must be used in the <code>get</code> method to
+ * read the value of that parameter.
* <p/>
- * This version of <code>registerOutParameter</code> should be
- * used when the parameter is of JDBC type <code>NUMERIC</code>
- * or <code>DECIMAL</code>.
+ * This version of <code>registerOutParameter</code> should be used when the
+ * parameter is of JDBC type <code>NUMERIC</code> or <code>DECIMAL</code>.
*
* @param parameterName the name of the parameter
- * @param sqlType SQL type code defined by <code>java.sql.Types</code>.
- * @param scale the desired number of digits to the right of the
- * decimal point. It must be greater than or equal to zero.
+ * @param sqlType SQL type code defined by <code>java.sql.Types</code>.
+ * @param scale the desired number of digits to the right of the decimal point.
+ * It must be greater than or equal to zero.
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
* @since 1.4
@@ -589,35 +558,33 @@
}
/**
- * Registers the designated output parameter. This version of
- * the method <code>registerOutParameter</code>
- * should be used for a user-named or REF output parameter. Examples
- * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
- * named array types.
+ * Registers the designated output parameter. This version of the method
+ * <code>registerOutParameter</code> should be used for a user-named or REF
+ * output parameter. Examples of user-named types include: STRUCT, DISTINCT,
+ * JAVA_OBJECT, and named array types.
* <p/>
- * Before executing a stored procedure call, you must explicitly
- * call <code>registerOutParameter</code> to register the type from
- * <code>java.sql.Types</code> for each
- * OUT parameter. For a user-named parameter the fully-qualified SQL
- * type name of the parameter should also be given, while a REF
- * parameter requires that the fully-qualified type name of the
- * referenced type be given. A JDBC driver that does not need the
- * type code and type name information may ignore it. To be portable,
- * however, applications should always provide these values for
- * user-named and REF parameters.
+ * Before executing a stored procedure call, you must explicitly call
+ * <code>registerOutParameter</code> to register the type from
+ * <code>java.sql.Types</code> for each OUT parameter. For a user-named
+ * parameter the fully-qualified SQL type name of the parameter should also be
+ * given, while a REF parameter requires that the fully-qualified type name of
+ * the referenced type be given. A JDBC driver that does not need the type code
+ * and type name information may ignore it. To be portable, however,
+ * applications should always provide these values for user-named and REF
+ * parameters.
* <p/>
- * Although it is intended for user-named and REF parameters,
- * this method may be used to register a parameter of any JDBC type.
- * If the parameter does not have a user-named or REF type, the
- * typeName parameter is ignored.
+ * Although it is intended for user-named and REF parameters, this method may be
+ * used to register a parameter of any JDBC type. If the parameter does not have
+ * a user-named or REF type, the typeName parameter is ignored.
* <p/>
- * <P><B>Note:</B> When reading the value of an out parameter, you
- * must use the <code>getXXX</code> method whose Java type XXX corresponds to the
- * parameter's registered SQL type.
+ * <P>
+ * <B>Note:</B> When reading the value of an out parameter, you must use the
+ * <code>getXXX</code> method whose Java type XXX corresponds to the parameter's
+ * registered SQL type.
*
* @param parameterName the name of the parameter
- * @param sqlType a value from {@link java.sql.Types}
- * @param typeName the fully-qualified name of an SQL structured type
+ * @param sqlType a value from {@link java.sql.Types}
+ * @param typeName the fully-qualified name of an SQL structured type
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
* @since 1.4
@@ -627,16 +594,14 @@
}
/**
- * Retrieves the value of the designated JDBC <code>DATALINK</code> parameter as a
- * <code>java.net.URL</code> object.
+ * Retrieves the value of the designated JDBC <code>DATALINK</code> parameter as
+ * a <code>java.net.URL</code> object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
- * @return a <code>java.net.URL</code> object that represents the
- * JDBC <code>DATALINK</code> value used as the designated
- * parameter
- * @throws java.sql.SQLException if a database access error occurs,
- * or if the URL being returned is
- * not a valid URL on the Java platform
+ * @return a <code>java.net.URL</code> object that represents the JDBC
+ * <code>DATALINK</code> value used as the designated parameter
+ * @throws java.sql.SQLException if a database access error occurs, or if the
+ * URL being returned is not a valid URL on the Java platform
* @see #setURL
* @since 1.4
*/
@@ -646,13 +611,13 @@
/**
* Sets the designated parameter to the given <code>java.net.URL</code> object.
- * The driver converts this to an SQL <code>DATALINK</code> value when
- * it sends it to the database.
+ * The driver converts this to an SQL <code>DATALINK</code> value when it sends
+ * it to the database.
*
* @param parameterName the name of the parameter
- * @param val the parameter value
- * @throws java.sql.SQLException if a database access error occurs,
- * or if a URL is malformed
+ * @param val the parameter value
+ * @throws java.sql.SQLException if a database access error occurs, or if a URL
+ * is malformed
* @see #getURL
* @since 1.4
*/
@@ -663,10 +628,11 @@
/**
* Sets the designated parameter to SQL <code>NULL</code>.
* <p/>
- * <P><B>Note:</B> You must specify the parameter's SQL type.
+ * <P>
+ * <B>Note:</B> You must specify the parameter's SQL type.
*
* @param parameterName the name of the parameter
- * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
+ * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -676,11 +642,11 @@
/**
* Sets the designated parameter to the given Java <code>boolean</code> value.
- * The driver converts this
- * to an SQL <code>BIT</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>BIT</code> value when it sends it to
+ * the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getBoolean
* @since 1.4
@@ -690,12 +656,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>byte</code> value.
- * The driver converts this
- * to an SQL <code>TINYINT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>byte</code> value. The
+ * driver converts this to an SQL <code>TINYINT</code> value when it sends it to
+ * the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getByte
* @since 1.4
@@ -705,12 +671,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>short</code> value.
- * The driver converts this
- * to an SQL <code>SMALLINT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>short</code> value. The
+ * driver converts this to an SQL <code>SMALLINT</code> value when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getShort
* @since 1.4
@@ -720,12 +686,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>int</code> value.
- * The driver converts this
- * to an SQL <code>INTEGER</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>int</code> value. The
+ * driver converts this to an SQL <code>INTEGER</code> value when it sends it to
+ * the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getInt
* @since 1.4
@@ -735,12 +701,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>long</code> value.
- * The driver converts this
- * to an SQL <code>BIGINT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>long</code> value. The
+ * driver converts this to an SQL <code>BIGINT</code> value when it sends it to
+ * the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getLong
* @since 1.4
@@ -750,12 +716,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>float</code> value.
- * The driver converts this
- * to an SQL <code>FLOAT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>float</code> value. The
+ * driver converts this to an SQL <code>FLOAT</code> value when it sends it to
+ * the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getFloat
* @since 1.4
@@ -766,11 +732,11 @@
/**
* Sets the designated parameter to the given Java <code>double</code> value.
- * The driver converts this
- * to an SQL <code>DOUBLE</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>DOUBLE</code> value when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getDouble
* @since 1.4
@@ -780,13 +746,12 @@
}
/**
- * Sets the designated parameter to the given
- * <code>java.math.BigDecimal</code> value.
- * The driver converts this to an SQL <code>NUMERIC</code> value when
- * it sends it to the database.
+ * Sets the designated parameter to the given <code>java.math.BigDecimal</code>
+ * value. The driver converts this to an SQL <code>NUMERIC</code> value when it
+ * sends it to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getBigDecimal
* @since 1.4
@@ -797,14 +762,13 @@
/**
* Sets the designated parameter to the given Java <code>String</code> value.
- * The driver converts this
- * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
- * (depending on the argument's
- * size relative to the driver's limits on <code>VARCHAR</code> values)
- * when it sends it to the database.
+ * The driver converts this to an SQL <code>VARCHAR</code> or
+ * <code>LONGVARCHAR</code> value (depending on the argument's size relative to
+ * the driver's limits on <code>VARCHAR</code> values) when it sends it to the
+ * database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getString
* @since 1.4
@@ -814,14 +778,13 @@
}
/**
- * Sets the designated parameter to the given Java array of bytes.
- * The driver converts this to an SQL <code>VARBINARY</code> or
- * <code>LONGVARBINARY</code> (depending on the argument's size relative
- * to the driver's limits on <code>VARBINARY</code> values) when it sends
- * it to the database.
+ * Sets the designated parameter to the given Java array of bytes. The driver
+ * converts this to an SQL <code>VARBINARY</code> or <code>LONGVARBINARY</code>
+ * (depending on the argument's size relative to the driver's limits on
+ * <code>VARBINARY</code> values) when it sends it to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getBytes
* @since 1.4
@@ -832,11 +795,11 @@
/**
* Sets the designated parameter to the given <code>java.sql.Date</code> value.
- * The driver converts this
- * to an SQL <code>DATE</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>DATE</code> value when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getDate
* @since 1.4
@@ -847,11 +810,11 @@
/**
* Sets the designated parameter to the given <code>java.sql.Time</code> value.
- * The driver converts this
- * to an SQL <code>TIME</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>TIME</code> value when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getTime
* @since 1.4
@@ -861,13 +824,12 @@
}
/**
- * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
- * The driver
- * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
- * database.
+ * Sets the designated parameter to the given <code>java.sql.Timestamp</code>
+ * value. The driver converts this to an SQL <code>TIMESTAMP</code> value when
+ * it sends it to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #getTimestamp
* @since 1.4
@@ -877,21 +839,20 @@
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * 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</code> parameter, it may be more practical to send it via a
+ * <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
*
* @param parameterName the name of the parameter
- * @param x the Java input stream that contains the ASCII parameter value
- * @param length the number of bytes in the stream
+ * @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
* @since 1.4
*/
@@ -900,20 +861,19 @@
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the stream
- * as needed until end-of-file is reached.
+ * 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</code> parameter, it may be more practical to send it via
+ * a <code>java.io.InputStream</code> object. The data will be read from the
+ * stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
*
* @param parameterName the name of the parameter
- * @param x the java input stream which contains the binary parameter value
- * @param length the number of bytes in the stream
+ * @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
* @since 1.4
*/
@@ -926,28 +886,28 @@
* argument must be an object type; for integral values, the
* <code>java.lang</code> 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>
+ * 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</code>),
- * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
- * to the SQL data stream.
- * If, on the other hand, the object is of a class implementing
- * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>Struct</code>,
- * or <code>Array</code>, the driver should pass it to the database as a
- * value of the corresponding SQL type.
+ * If the object has a custom mapping (is of a class implementing the interface
+ * <code>SQLData</code>), the JDBC driver should call the method
+ * <code>SQLData.writeSQL</code> to write it to the SQL data stream. If, on the
+ * other hand, the object is of a class implementing <code>Ref</code>,
+ * <code>Blob</code>, <code>Clob</code>, <code>Struct</code>, or
+ * <code>Array</code>, the driver should pass it to the database as a value of
+ * the corresponding SQL type.
* <p/>
- * Note that this method may be used to pass datatabase-
- * specific abstract data types.
+ * Note that this method may be used to pass datatabase- specific abstract data
+ * types.
*
* @param parameterName the name of the parameter
- * @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.
+ * @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
* @see #getObject
@@ -958,14 +918,14 @@
}
/**
- * Sets the value of the designated parameter with the given object.
- * This method is like the method <code>setObject</code>
- * above, except that it assumes a scale of zero.
+ * Sets the value of the designated parameter with the given object. This method
+ * is like the method <code>setObject</code> above, except that it assumes a
+ * scale of zero.
*
* @param parameterName the name of the parameter
- * @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
+ * @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
* @see #getObject
* @since 1.4
@@ -975,34 +935,34 @@
}
/**
- * Sets the value of the designated parameter with the given object.
- * The second parameter must be of type <code>Object</code>; therefore, the
+ * Sets the value of the designated parameter with the given object. The second
+ * parameter must be of type <code>Object</code>; therefore, the
* <code>java.lang</code> equivalent objects should be used for built-in types.
* <p/>
- * <p>The JDBC specification specifies a standard mapping from
- * Java <code>Object</code> types to SQL types. The given argument
- * will be converted to the corresponding SQL type before being
- * sent to the database.
+ * <p>
+ * The JDBC specification specifies a standard mapping from Java
+ * <code>Object</code> 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>
+ * 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</code>,
- * the JDBC driver should call the method <code>SQLData.writeSQL</code>
- * to write it to the SQL data stream.
- * If, on the other hand, the object is of a class implementing
- * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>Struct</code>,
- * or <code>Array</code>, the driver should pass it to the database as a
- * value of the corresponding SQL type.
+ * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write
+ * it to the SQL data stream. If, on the other hand, the object is of a class
+ * implementing <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
+ * <code>Struct</code>, or <code>Array</code>, 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.
+ * object is of a class implementing more than one of the interfaces named
+ * above.
*
* @param parameterName the name of the parameter
- * @param x the object containing the input parameter value
- * @throws java.sql.SQLException if a database access error occurs or if the given
- * <code>Object</code> parameter is ambiguous
+ * @param x the object containing the input parameter value
+ * @throws java.sql.SQLException if a database access error occurs or if the
+ * given <code>Object</code> parameter is ambiguous
* @see #getObject
* @since 1.4
*/
@@ -1011,22 +971,21 @@
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object, which
+ * is the given number of characters long. When a very large UNICODE value is
+ * input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
*
* @param parameterName the name of the parameter
- * @param reader the <code>java.io.Reader</code> object that
- * contains the UNICODE data used as the designated parameter
- * @param length the number of characters in the stream
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * UNICODE data used as the designated parameter
+ * @param length the number of characters in the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -1036,18 +995,18 @@
/**
* Sets the designated parameter to the given <code>java.sql.Date</code> value,
- * using the given <code>Calendar</code> object. The driver uses
- * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
- * which the driver then sends to the database. With a
- * a <code>Calendar</code> object, the driver can calculate the date
- * taking into account a custom timezone. If no
- * <code>Calendar</code> object is specified, the driver uses the default
- * timezone, which is that of the virtual machine running the application.
+ * using the given <code>Calendar</code> object. The driver uses the
+ * <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
+ * which the driver then sends to the database. With a a <code>Calendar</code>
+ * object, the driver can calculate the date taking into account a custom
+ * timezone. If no <code>Calendar</code> object is specified, the driver uses
+ * the default timezone, which is that of the virtual machine running the
+ * application.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the date
+ * @param x the parameter value
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the date
* @throws java.sql.SQLException if a database access error occurs
* @see #getDate
* @since 1.4
@@ -1058,18 +1017,18 @@
/**
* Sets the designated parameter to the given <code>java.sql.Time</code> value,
- * using the given <code>Calendar</code> object. The driver uses
- * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
- * which the driver then sends to the database. With a
- * a <code>Calendar</code> object, the driver can calculate the time
- * taking into account a custom timezone. If no
- * <code>Calendar</code> object is specified, the driver uses the default
- * timezone, which is that of the virtual machine running the application.
+ * using the given <code>Calendar</code> object. The driver uses the
+ * <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
+ * which the driver then sends to the database. With a a <code>Calendar</code>
+ * object, the driver can calculate the time taking into account a custom
+ * timezone. If no <code>Calendar</code> object is specified, the driver uses
+ * the default timezone, which is that of the virtual machine running the
+ * application.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the time
+ * @param x the parameter value
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the time
* @throws java.sql.SQLException if a database access error occurs
* @see #getTime
* @since 1.4
@@ -1079,19 +1038,19 @@
}
/**
- * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
- * using the given <code>Calendar</code> object. The driver uses
- * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
- * which the driver then sends to the database. With a
- * a <code>Calendar</code> object, the driver can calculate the timestamp
- * taking into account a custom timezone. If no
- * <code>Calendar</code> object is specified, the driver uses the default
- * timezone, which is that of the virtual machine running the application.
+ * Sets the designated parameter to the given <code>java.sql.Timestamp</code>
+ * value, using the given <code>Calendar</code> object. The driver uses the
+ * <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code>
+ * value, which the driver then sends to the database. With a a
+ * <code>Calendar</code> object, the driver can calculate the timestamp taking
+ * into account a custom timezone. If no <code>Calendar</code> object is
+ * specified, the driver uses the default timezone, which is that of the virtual
+ * machine running the application.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the timestamp
+ * @param x the parameter value
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the timestamp
* @throws java.sql.SQLException if a database access error occurs
* @see #getTimestamp
* @since 1.4
@@ -1101,30 +1060,27 @@
}
/**
- * Sets the designated parameter to SQL <code>NULL</code>.
- * This version of the method <code>setNull</code> 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.
+ * Sets the designated parameter to SQL <code>NULL</code>. This version of the
+ * method <code>setNull</code> 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><B>Note:</B> 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>
+ * <B>Note:</B> 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.
+ * 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 parameterName the name of the parameter
- * @param sqlType a value from <code>java.sql.Types</code>
- * @param typeName the fully-qualified name of an SQL user-defined type;
- * ignored if the parameter is not a user-defined type or
- * SQL <code>REF</code> value
+ * @param sqlType a value from <code>java.sql.Types</code>
+ * @param typeName the fully-qualified name of an SQL user-defined type; ignored
+ * if the parameter is not a user-defined type or SQL <code>REF</code> value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -1133,19 +1089,17 @@
}
/**
- * Retrieves the value of a JDBC <code>CHAR</code>, <code>VARCHAR</code>,
- * or <code>LONGVARCHAR</code> parameter as a <code>String</code> in
- * the Java programming language.
+ * Retrieves the value of a JDBC <code>CHAR</code>, <code>VARCHAR</code>, or
+ * <code>LONGVARCHAR</code> parameter as a <code>String</code> in the Java
+ * programming language.
* <p/>
- * For the fixed-length type JDBC <code>CHAR</code>,
- * the <code>String</code> object
- * returned has exactly the same value the JDBC
- * <code>CHAR</code> value had in the
- * database, including any padding added by the database.
+ * For the fixed-length type JDBC <code>CHAR</code>, the <code>String</code>
+ * object returned has exactly the same value the JDBC <code>CHAR</code> value
+ * had in the database, including any padding added by the database.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setString
* @since 1.4
@@ -1159,8 +1113,8 @@
* <code>boolean</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>false</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>false</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBoolean
* @since 1.4
@@ -1170,12 +1124,12 @@
}
/**
- * Retrieves the value of a JDBC <code>TINYINT</code> parameter as a <code>byte</code>
- * in the Java programming language.
+ * Retrieves the value of a JDBC <code>TINYINT</code> parameter as a
+ * <code>byte</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setByte
* @since 1.4
@@ -1185,12 +1139,12 @@
}
/**
- * Retrieves the value of a JDBC <code>SMALLINT</code> parameter as a <code>short</code>
- * in the Java programming language.
+ * Retrieves the value of a JDBC <code>SMALLINT</code> parameter as a
+ * <code>short</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>0</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setShort
* @since 1.4
@@ -1200,12 +1154,12 @@
}
/**
- * Retrieves the value of a JDBC <code>INTEGER</code> parameter as an <code>int</code>
- * in the Java programming language.
+ * Retrieves the value of a JDBC <code>INTEGER</code> parameter as an
+ * <code>int</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result is <code>0</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setInt
* @since 1.4
@@ -1215,12 +1169,12 @@
}
/**
- * Retrieves the value of a JDBC <code>BIGINT</code> parameter as a <code>long</code>
- * in the Java programming language.
+ * Retrieves the value of a JDBC <code>BIGINT</code> parameter as a
+ * <code>long</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result is <code>0</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setLong
* @since 1.4
@@ -1230,12 +1184,12 @@
}
/**
- * Retrieves the value of a JDBC <code>FLOAT</code> parameter as a <code>float</code>
- * in the Java programming language.
+ * Retrieves the value of a JDBC <code>FLOAT</code> parameter as a
+ * <code>float</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result is <code>0</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setFloat
* @since 1.4
@@ -1245,12 +1199,12 @@
}
/**
- * Retrieves the value of a JDBC <code>DOUBLE</code> parameter as a <code>double</code>
- * in the Java programming language.
+ * Retrieves the value of a JDBC <code>DOUBLE</code> parameter as a
+ * <code>double</code> in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result is <code>0</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>0</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setDouble
* @since 1.4
@@ -1261,12 +1215,12 @@
/**
* Retrieves the value of a JDBC <code>BINARY</code> or <code>VARBINARY</code>
- * parameter as an array of <code>byte</code> values in the Java
- * programming language.
+ * parameter as an array of <code>byte</code> values in the Java programming
+ * language.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result is
- * <code>null</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBytes
* @since 1.4
@@ -1280,8 +1234,8 @@
* <code>java.sql.Date</code> object.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setDate
* @since 1.4
@@ -1295,8 +1249,8 @@
* <code>java.sql.Time</code> object.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTime
* @since 1.4
@@ -1310,8 +1264,8 @@
* <code>java.sql.Timestamp</code> object.
*
* @param parameterName the name of the parameter
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result
- * is <code>null</code>.
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTimestamp
* @since 1.4
@@ -1322,14 +1276,14 @@
/**
* Retrieves the value of a parameter as an <code>Object</code> in the Java
- * programming language. If the value is an SQL <code>NULL</code>, the
- * driver returns a Java <code>null</code>.
+ * programming language. If the value is an SQL <code>NULL</code>, the driver
+ * returns a Java <code>null</code>.
* <p/>
- * This method returns a Java object whose type corresponds to the JDBC
- * type that was registered for this parameter using the method
- * <code>registerOutParameter</code>. By registering the target JDBC
- * type as <code>java.sql.Types.OTHER</code>, this method can be used
- * to read database-specific abstract data types.
+ * This method returns a Java object whose type corresponds to the JDBC type
+ * that was registered for this parameter using the method
+ * <code>registerOutParameter</code>. By registering the target JDBC type as
+ * <code>java.sql.Types.OTHER</code>, this method can be used to read
+ * database-specific abstract data types.
*
* @param parameterName the name of the parameter
* @return A <code>java.lang.Object</code> holding the OUT parameter value.
@@ -1344,12 +1298,12 @@
/**
* Retrieves the value of a JDBC <code>NUMERIC</code> parameter as a
- * <code>java.math.BigDecimal</code> object with as many digits to the
- * right of the decimal point as the value contains.
+ * <code>java.math.BigDecimal</code> object with as many digits to the right of
+ * the decimal point as the value contains.
*
* @param parameterName the name of the parameter
- * @return the parameter value in full precision. If the value is
- * SQL <code>NULL</code>, the result is <code>null</code>.
+ * @return the parameter value in full precision. If the value is SQL
+ * <code>NULL</code>, the result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setBigDecimal
* @since 1.4
@@ -1363,9 +1317,9 @@
* parameter as a {@link java.sql.Ref} object in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value as a <code>Ref</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>,
- * the value <code>null</code> is returned.
+ * @return the parameter value as a <code>Ref</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -1378,9 +1332,9 @@
* {@link java.sql.Blob} object in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value as a <code>Blob</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>,
- * the value <code>null</code> is returned.
+ * @return the parameter value as a <code>Blob</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -1393,9 +1347,9 @@
* <code>Clob</code> object in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value as a <code>Clob</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>,
- * the value <code>null</code> is returned.
+ * @return the parameter value as a <code>Clob</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -1408,9 +1362,9 @@
* {@link java.sql.Array} object in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value as an <code>Array</code> object in
- * Java programming language. If the value was SQL <code>NULL</code>,
- * the value <code>null</code> is returned.
+ * @return the parameter value as an <code>Array</code> object in Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -1420,19 +1374,17 @@
/**
* Retrieves the value of a JDBC <code>DATE</code> parameter as a
- * <code>java.sql.Date</code> object, using
- * the given <code>Calendar</code> object
- * to construct the date.
- * With a <code>Calendar</code> object, the driver
- * can calculate the date taking into account a custom timezone and locale.
- * If no <code>Calendar</code> object is specified, the driver uses the
- * default timezone and locale.
+ * <code>java.sql.Date</code> object, using the given <code>Calendar</code>
+ * object to construct the date. With a <code>Calendar</code> object, the driver
+ * can calculate the date taking into account a custom timezone and locale. If
+ * no <code>Calendar</code> object is specified, the driver uses the default
+ * timezone and locale.
*
* @param parameterName the name of the parameter
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the date
- * @return the parameter value. If the value is SQL <code>NULL</code>,
- * the result is <code>null</code>.
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the date
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setDate
* @since 1.4
@@ -1443,19 +1395,17 @@
/**
* Retrieves the value of a JDBC <code>TIME</code> parameter as a
- * <code>java.sql.Time</code> object, using
- * the given <code>Calendar</code> object
- * to construct the time.
- * With a <code>Calendar</code> object, the driver
- * can calculate the time taking into account a custom timezone and locale.
- * If no <code>Calendar</code> object is specified, the driver uses the
- * default timezone and locale.
+ * <code>java.sql.Time</code> object, using the given <code>Calendar</code>
+ * object to construct the time. With a <code>Calendar</code> object, the driver
+ * can calculate the time taking into account a custom timezone and locale. If
+ * no <code>Calendar</code> object is specified, the driver uses the default
+ * timezone and locale.
*
* @param parameterName the name of the parameter
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the time
- * @return the parameter value; if the value is SQL <code>NULL</code>, the result is
- * <code>null</code>.
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the time
+ * @return the parameter value; if the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTime
* @since 1.4
@@ -1466,19 +1416,17 @@
/**
* Retrieves the value of a JDBC <code>TIMESTAMP</code> parameter as a
- * <code>java.sql.Timestamp</code> object, using
- * the given <code>Calendar</code> object to construct
- * the <code>Timestamp</code> object.
- * With a <code>Calendar</code> object, the driver
- * can calculate the timestamp taking into account a custom timezone and locale.
- * If no <code>Calendar</code> object is specified, the driver uses the
- * default timezone and locale.
+ * <code>java.sql.Timestamp</code> object, using the given <code>Calendar</code>
+ * object to construct the <code>Timestamp</code> object. With a
+ * <code>Calendar</code> object, the driver can calculate the timestamp taking
+ * into account a custom timezone and locale. If no <code>Calendar</code> object
+ * is specified, the driver uses the default timezone and locale.
*
* @param parameterName the name of the parameter
- * @param cal the <code>Calendar</code> object the driver will use
- * to construct the timestamp
- * @return the parameter value. If the value is SQL <code>NULL</code>, the result is
- * <code>null</code>.
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the timestamp
+ * @return the parameter value. If the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @see #setTimestamp
* @since 1.4
@@ -1492,11 +1440,11 @@
* <code>java.net.URL</code> object.
*
* @param parameterName the name of the parameter
- * @return the parameter value as a <code>java.net.URL</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>, the
- * value <code>null</code> is returned.
- * @throws java.sql.SQLException if a database access error occurs,
- * or if there is a problem with the URL
+ * @return the parameter value as a <code>java.net.URL</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
+ * @throws java.sql.SQLException if a database access error occurs, or if there
+ * is a problem with the URL
* @see #setURL
* @since 1.4
*/
@@ -1505,17 +1453,16 @@
}
/**
- * Returns an object representing the value of OUT parameter
- * <code>i</code> and uses <code>map</code> for the custom
- * mapping of the parameter value.
+ * Returns an object representing the value of OUT parameter <code>i</code> and
+ * uses <code>map</code> for the custom mapping of the parameter value.
* <p/>
- * This method returns a Java object whose type corresponds to the
- * JDBC type that was registered for this parameter using the method
- * <code>registerOutParameter</code>. By registering the target
- * JDBC type as <code>java.sql.Types.OTHER</code>, this method can
- * be used to read database-specific abstract data types.
+ * This method returns a Java object whose type corresponds to the JDBC type
+ * that was registered for this parameter using the method
+ * <code>registerOutParameter</code>. By registering the target JDBC type as
+ * <code>java.sql.Types.OTHER</code>, this method can be used to read
+ * database-specific abstract data types.
*
- * @param i the first parameter is 1, the second is 2, and so on
+ * @param i the first parameter is 1, the second is 2, and so on
* @param map the mapping from SQL type names to Java classes
* @return a <code>java.lang.Object</code> holding the OUT parameter value
* @throws java.sql.SQLException if a database access error occurs
@@ -1527,18 +1474,17 @@
}
/**
- * Returns an object representing the value of OUT parameter
- * <code>i</code> and uses <code>map</code> for the custom
- * mapping of the parameter value.
+ * Returns an object representing the value of OUT parameter <code>i</code> and
+ * uses <code>map</code> for the custom mapping of the parameter value.
* <p/>
- * This method returns a Java object whose type corresponds to the
- * JDBC type that was registered for this parameter using the method
- * <code>registerOutParameter</code>. By registering the target
- * JDBC type as <code>java.sql.Types.OTHER</code>, this method can
- * be used to read database-specific abstract data types.
+ * This method returns a Java object whose type corresponds to the JDBC type
+ * that was registered for this parameter using the method
+ * <code>registerOutParameter</code>. By registering the target JDBC type as
+ * <code>java.sql.Types.OTHER</code>, this method can be used to read
+ * database-specific abstract data types.
*
* @param parameterName the name of the parameter
- * @param map the mapping from SQL type names to Java classes
+ * @param map the mapping from SQL type names to Java classes
* @return a <code>java.lang.Object</code> holding the OUT parameter value
* @throws java.sql.SQLException if a database access error occurs
* @see #setObject
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionHolder.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionHolder.java
index 1c81834..f110bab 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionHolder.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionHolder.java
@@ -16,6 +16,18 @@
package com.sun.gjc.spi.base;
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.gjc.common.DataSourceObjectBuilder;
import com.sun.gjc.spi.ManagedConnectionImpl;
@@ -23,48 +35,41 @@
import com.sun.logging.LogDomains;
import jakarta.resource.ResourceException;
-import java.sql.*;
-import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import jakarta.resource.spi.ConnectionRequestInfo;
+import jakarta.resource.spi.LazyAssociatableConnectionManager;
+import jakarta.resource.spi.LazyEnlistableConnectionManager;
+import jakarta.resource.spi.ManagedConnectionFactory;
/**
- * Holds the java.sql.Connection object, which is to be
- * passed to the application program.
+ * Holds the java.sql.Connection object, which is to be passed to the
+ * application program.
*
* @author Binod P.G
* @version 1.0, 02/07/23
*/
public abstract class ConnectionHolder implements Connection {
- protected Connection con;
+ protected final static Logger _logger = LogDomains.getLogger(ManagedConnectionImpl.class, LogDomains.RSR_LOGGER);
+ protected final static StringManager sm = StringManager.getManager(DataSourceObjectBuilder.class);
- protected ManagedConnectionImpl mc;
+ protected Connection connection;
+ protected ManagedConnectionImpl managedConnectionImpl;
- protected boolean wrappedAlready = false;
-
- protected boolean isClosed = false;
-
+ protected boolean wrappedAlready;
+ protected boolean isClosed;
protected boolean valid = true;
+ protected boolean active;
- protected boolean active = false;
+ private LazyAssociatableConnectionManager lazyAssocCm_;
+ private LazyEnlistableConnectionManager lazyEnlistCm_;
- private jakarta.resource.spi.LazyAssociatableConnectionManager lazyAssocCm_;
- private jakarta.resource.spi.LazyEnlistableConnectionManager lazyEnlistCm_;
-
- private jakarta.resource.spi.ConnectionRequestInfo cxReqInfo_;
-
- private jakarta.resource.spi.ManagedConnectionFactory mcf_;
+ private ConnectionRequestInfo connectionRequestInfo;
+ private ManagedConnectionFactory managedConnectionFactory;
protected int statementTimeout;
protected boolean statementTimeoutEnabled;
- protected final static Logger _logger;
-
- static {
- _logger = LogDomains.getLogger(ManagedConnectionImpl.class, LogDomains.RSR_LOGGER);
- }
- private MethodExecutor executor = null;
+ private MethodExecutor executor;
public static enum ConnectionType {
LAZY_ENLISTABLE, LAZY_ASSOCIATABLE, STANDARD
@@ -73,18 +78,14 @@
private ConnectionType myType_ = ConnectionType.STANDARD;
/**
- * The active flag is false when the connection handle is
- * created. When a method is invoked on this object, it asks
- * the ManagedConnection if it can be the active connection
- * handle out of the multiple connection handles. If the
- * ManagedConnection reports that this connection handle
- * can be active by setting this flag to true via the setActive
- * function, the above method invocation succeeds; otherwise
- * an exception is thrown.
+ * The active flag is false when the connection handle is created. When a method
+ * is invoked on this object, it asks the ManagedConnection if it can be the
+ * active connection handle out of the multiple connection handles. If the
+ * ManagedConnection reports that this connection handle can be active by
+ * setting this flag to true via the setActive function, the above method
+ * invocation succeeds; otherwise an exception is thrown.
*/
- protected final static StringManager sm = StringManager.getManager(
- DataSourceObjectBuilder.class);
/**
@@ -92,12 +93,11 @@
*
* @param con <code>java.sql.Connection</code> object.
*/
- public ConnectionHolder(Connection con, ManagedConnectionImpl mc,
- jakarta.resource.spi.ConnectionRequestInfo cxRequestInfo) {
- this.con = con;
- this.mc = mc;
- mcf_ = mc.getMcf();
- cxReqInfo_ = cxRequestInfo;
+ public ConnectionHolder(Connection con, ManagedConnectionImpl mc, ConnectionRequestInfo cxRequestInfo) {
+ this.connection = con;
+ this.managedConnectionImpl = mc;
+ managedConnectionFactory = mc.getMcf();
+ connectionRequestInfo = cxRequestInfo;
statementTimeout = mc.getStatementTimeout();
executor = new MethodExecutor();
if (statementTimeout > 0) {
@@ -111,7 +111,7 @@
* @return Connection object.
*/
public Connection getConnection() {
- return con;
+ return connection;
}
/**
@@ -133,13 +133,13 @@
}
/**
- * Returns the <code>ManagedConnection</code> instance responsible
- * for this connection.
+ * Returns the <code>ManagedConnection</code> instance responsible for this
+ * connection.
*
* @return <code>ManagedConnection</code> instance.
*/
public ManagedConnectionImpl getManagedConnection() {
- return mc;
+ return managedConnectionImpl;
}
/**
@@ -147,30 +147,30 @@
* supplied. Also replace <code>ManagedConnection</code> link.
*
* @param con <code>Connection</code> object.
- * @param mc <code> ManagedConnection</code> object.
+ * @param mc <code> ManagedConnection</code> object.
*/
public void associateConnection(Connection con, ManagedConnectionImpl mc) {
- this.mc = mc;
- this.con = con;
+ this.managedConnectionImpl = mc;
+ this.connection = con;
}
/**
- * Dis-associate ManagedConnection and actual-connection from this user connection.
- * Used when lazy-connection-association is ON.
+ * Dis-associate ManagedConnection and actual-connection from this user
+ * connection. Used when lazy-connection-association is ON.
*/
public void dissociateConnection() {
- this.mc = null;
- this.con = null;
+ this.managedConnectionImpl = null;
+ this.connection = null;
}
/**
- * Clears all warnings reported for the underlying connection object.
+ * Clears all warnings reported for the underlying connection object.
*
* @throws SQLException In case of a database error.
*/
public void clearWarnings() throws SQLException {
checkValidity();
- con.clearWarnings();
+ connection.clearWarnings();
}
/**
@@ -187,10 +187,10 @@
}
isClosed = true;
- if (mc != null) {
- //mc might be null if this is a lazyAssociatable connection
- //and has not been associated yet or has been disassociated
- mc.connectionClosed(null, this);
+ if (managedConnectionImpl != null) {
+ // mc might be null if this is a lazyAssociatable connection
+ // and has not been associated yet or has been disassociated
+ managedConnectionImpl.connectionClosed(null, this);
}
}
@@ -207,7 +207,7 @@
* @throws SQLException In case of a database error.
*/
void actualClose() throws SQLException {
- con.close();
+ connection.close();
}
/**
@@ -217,7 +217,7 @@
*/
public void commit() throws SQLException {
checkValidity();
- con.commit();
+ connection.commit();
}
/**
@@ -229,21 +229,23 @@
public Statement createStatement() throws SQLException {
checkValidity();
jdbcPreInvoke();
- Statement stmt = con.createStatement();
+
+ Statement statement = connection.createStatement();
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ statement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ statement.close();
}
}
- return stmt;
+
+ return statement;
}
/**
* Creates a statement from the underlying Connection.
*
- * @param resultSetType Type of the ResultSet
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code>Statement</code> object.
* @throws SQLException In case of a database error.
@@ -251,51 +253,54 @@
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
checkValidity();
jdbcPreInvoke();
- Statement stmt = con.createStatement(resultSetType, resultSetConcurrency);
+
+ Statement statement = connection.createStatement(resultSetType, resultSetConcurrency);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ statement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ statement.close();
}
}
- return stmt;
+
+ return statement;
}
/**
* Creates a statement from the underlying Connection.
*
- * @param resultSetType Type of the ResultSet
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code>Statement</code> object.
* @throws SQLException In case of a database error.
*/
- public Statement createStatement(int resultSetType, int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
+ public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
checkValidity();
jdbcPreInvoke();
- Statement stmt = con.createStatement(resultSetType, resultSetConcurrency,
- resultSetHoldability);
+
+ Statement statement = connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ statement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ statement.close();
}
}
- return stmt;
+
+ return statement;
}
/**
- * Retrieves the current auto-commit mode for the underlying <code> Connection</code>.
+ * Retrieves the current auto-commit mode for the underlying
+ * <code> Connection</code>.
*
* @return The current state of connection's auto-commit mode.
* @throws SQLException In case of a database error.
*/
public boolean getAutoCommit() throws SQLException {
checkValidity();
- return con.getAutoCommit();
+ return connection.getAutoCommit();
}
/**
@@ -306,7 +311,7 @@
*/
public String getCatalog() throws SQLException {
checkValidity();
- return con.getCatalog();
+ return connection.getCatalog();
}
/**
@@ -318,7 +323,7 @@
*/
public int getHoldability() throws SQLException {
checkValidity();
- return con.getHoldability();
+ return connection.getHoldability();
}
/**
@@ -330,18 +335,19 @@
*/
public DatabaseMetaData getMetaData() throws SQLException {
checkValidity();
- return con.getMetaData();
+ return connection.getMetaData();
}
/**
- * Retrieves this <code>Connection</code> object's current transaction isolation level.
+ * Retrieves this <code>Connection</code> object's current transaction isolation
+ * level.
*
* @return Transaction level
* @throws SQLException In case of a database error.
*/
public int getTransactionIsolation() throws SQLException {
checkValidity();
- return con.getTransactionIsolation();
+ return connection.getTransactionIsolation();
}
/**
@@ -353,7 +359,7 @@
*/
public Map<String, Class<?>> getTypeMap() throws SQLException {
checkValidity();
- return con.getTypeMap();
+ return connection.getTypeMap();
}
/**
@@ -365,14 +371,14 @@
*/
public SQLWarning getWarnings() throws SQLException {
checkValidity();
- return con.getWarnings();
+ return connection.getWarnings();
}
/**
* Retrieves whether underlying <code>Connection</code> object is closed.
*
- * @return true if <code>Connection</code> object is closed, false
- * if it is closed.
+ * @return true if <code>Connection</code> object is closed, false if it is
+ * closed.
* @throws SQLException In case of a database error.
*/
public boolean isClosed() throws SQLException {
@@ -383,8 +389,8 @@
* Set the isClosed flag based on whether the underlying <code>Connection</code>
* object is closed.
*
- * @param flag true if <code>Connection</code> object is closed, false if
- * its not closed.
+ * @param flag true if <code>Connection</code> object is closed, false if its
+ * not closed.
*/
public void setClosed(boolean flag) {
isClosed = flag;
@@ -398,7 +404,7 @@
*/
public boolean isReadOnly() throws SQLException {
checkValidity();
- return con.isReadOnly();
+ return connection.isReadOnly();
}
/**
@@ -410,12 +416,12 @@
*/
public String nativeSQL(String sql) throws SQLException {
checkValidity();
- return con.nativeSQL(sql);
+ return connection.nativeSQL(sql);
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
* @param sql SQL Statement
* @return <code> CallableStatement</code> object.
@@ -424,7 +430,7 @@
public CallableStatement prepareCall(String sql) throws SQLException {
checkValidity();
jdbcPreInvoke();
- CallableStatement stmt = con.prepareCall(sql);
+ CallableStatement stmt = connection.prepareCall(sql);
if (statementTimeoutEnabled) {
stmt.setQueryTimeout(statementTimeout);
}
@@ -432,53 +438,53 @@
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code> CallableStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public CallableStatement prepareCall(String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
checkValidity();
jdbcPreInvoke();
- CallableStatement stmt = con.prepareCall(sql, resultSetType, resultSetConcurrency);
+
+ CallableStatement callableStatement = connection.prepareCall(sql, resultSetType, resultSetConcurrency);
if (statementTimeoutEnabled) {
- stmt.setQueryTimeout(statementTimeout);
+ callableStatement.setQueryTimeout(statementTimeout);
}
- return stmt;
+
+ return callableStatement;
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code> CallableStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public CallableStatement prepareCall(String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
checkValidity();
jdbcPreInvoke();
- CallableStatement stmt = con.prepareCall(sql, resultSetType, resultSetConcurrency,
- resultSetHoldability);
+
+ CallableStatement callableStatement = connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
if (statementTimeoutEnabled) {
- stmt.setQueryTimeout(statementTimeout);
+ callableStatement.setQueryTimeout(statementTimeout);
}
- return stmt;
+
+ return callableStatement;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
* @param sql SQL Statement
* @return <code> PreparedStatement</code> object.
@@ -487,122 +493,129 @@
public PreparedStatement prepareStatement(final String sql) throws SQLException {
checkValidity();
jdbcPreInvoke();
- PreparedStatement stmt = con.prepareStatement(sql);
+
+ PreparedStatement preparedStatement = connection.prepareStatement(sql);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ preparedStatement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ preparedStatement.close();
}
}
- return stmt;
+
+ return preparedStatement;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param autoGeneratedKeys a flag indicating AutoGeneratedKeys need to be returned.
+ * @param sql SQL Statement
+ * @param autoGeneratedKeys a flag indicating AutoGeneratedKeys need to be
+ * returned.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
public PreparedStatement prepareStatement(final String sql, int autoGeneratedKeys) throws SQLException {
checkValidity();
jdbcPreInvoke();
- PreparedStatement stmt = con.prepareStatement(sql, autoGeneratedKeys);
+
+ PreparedStatement preparedStatement = connection.prepareStatement(sql, autoGeneratedKeys);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ preparedStatement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ preparedStatement.close();
}
}
- return stmt;
+
+ return preparedStatement;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param columnIndexes an array of column indexes indicating the columns that should be
- * returned from the inserted row or rows.
+ * @param sql SQL Statement
+ * @param columnIndexes an array of column indexes indicating the columns that
+ * should be returned from the inserted row or rows.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
public PreparedStatement prepareStatement(final String sql, int[] columnIndexes) throws SQLException {
checkValidity();
jdbcPreInvoke();
- PreparedStatement stmt = con.prepareStatement(sql, columnIndexes);
+
+ PreparedStatement preparedStatement = connection.prepareStatement(sql, columnIndexes);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ preparedStatement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ preparedStatement.close();
}
}
- return stmt;
+
+ return preparedStatement;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(final String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
+ public PreparedStatement prepareStatement(final String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
checkValidity();
jdbcPreInvoke();
- PreparedStatement stmt = con.prepareStatement(sql, resultSetType, resultSetConcurrency);
+
+ PreparedStatement preparedStatement = connection.prepareStatement(sql, resultSetType, resultSetConcurrency);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ preparedStatement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ preparedStatement.close();
}
}
- return stmt;
+
+ return preparedStatement;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(final String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
+ public PreparedStatement prepareStatement(final String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
checkValidity();
jdbcPreInvoke();
- PreparedStatement stmt = con.prepareStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability);
+
+ PreparedStatement preparedStatement = connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ preparedStatement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ preparedStatement.close();
}
}
- return stmt;
+
+ return preparedStatement;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
+ * @param sql SQL Statement
* @param columnNames Name of bound columns.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
@@ -610,15 +623,17 @@
public PreparedStatement prepareStatement(final String sql, String[] columnNames) throws SQLException {
checkValidity();
jdbcPreInvoke();
- PreparedStatement stmt = con.prepareStatement(sql, columnNames);
+
+ PreparedStatement preparedStatement = connection.prepareStatement(sql, columnNames);
if (statementTimeoutEnabled) {
try {
- stmt.setQueryTimeout(statementTimeout);
+ preparedStatement.setQueryTimeout(statementTimeout);
} catch (SQLException ex) {
- stmt.close();
+ preparedStatement.close();
}
}
- return stmt;
+
+ return preparedStatement;
}
/**
@@ -629,7 +644,7 @@
*/
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
checkValidity();
- con.releaseSavepoint(savepoint);
+ connection.releaseSavepoint(savepoint);
}
/**
@@ -639,7 +654,7 @@
*/
public void rollback() throws SQLException {
checkValidity();
- con.rollback();
+ connection.rollback();
}
/**
@@ -649,7 +664,7 @@
*/
public void rollback(Savepoint savepoint) throws SQLException {
checkValidity();
- con.rollback(savepoint);
+ connection.rollback(savepoint);
}
/**
@@ -660,8 +675,8 @@
*/
public void setAutoCommit(boolean autoCommit) throws SQLException {
checkValidity();
- con.setAutoCommit(autoCommit);
- mc.setLastAutoCommitValue(autoCommit);
+ connection.setAutoCommit(autoCommit);
+ managedConnectionImpl.setLastAutoCommitValue(autoCommit);
}
/**
@@ -672,31 +687,31 @@
*/
public void setCatalog(String catalog) throws SQLException {
checkValidity();
- con.setCatalog(catalog);
+ connection.setCatalog(catalog);
}
/**
- * Sets the holdability of <code>ResultSet</code> objects created
- * using this <code>Connection</code> object.
+ * Sets the holdability of <code>ResultSet</code> objects created using this
+ * <code>Connection</code> object.
*
* @param holdability A <code>ResultSet</code> holdability constant
* @throws SQLException In case of a database error.
*/
public void setHoldability(int holdability) throws SQLException {
checkValidity();
- con.setHoldability(holdability);
+ connection.setHoldability(holdability);
}
/**
- * Puts the connection in read-only mode as a hint to the driver to
- * perform database optimizations.
+ * Puts the connection in read-only mode as a hint to the driver to perform
+ * database optimizations.
*
* @param readOnly true enables read-only mode, false disables it.
* @throws SQLException In case of a database error.
*/
public void setReadOnly(boolean readOnly) throws SQLException {
checkValidity();
- con.setReadOnly(readOnly);
+ connection.setReadOnly(readOnly);
}
/**
@@ -707,11 +722,12 @@
*/
public Savepoint setSavepoint() throws SQLException {
checkValidity();
- return con.setSavepoint();
+ return connection.setSavepoint();
}
/**
- * Creates a savepoint with the name and returns an object corresponding to that.
+ * Creates a savepoint with the name and returns an object corresponding to
+ * that.
*
* @param name Name of the savepoint.
* @return <code>Savepoint</code> object.
@@ -719,7 +735,7 @@
*/
public Savepoint setSavepoint(String name) throws SQLException {
checkValidity();
- return con.setSavepoint(name);
+ return connection.setSavepoint(name);
}
/**
@@ -730,19 +746,24 @@
*/
public void setTransactionIsolation(int level) throws SQLException {
checkValidity();
- con.setTransactionIsolation(level);
- mc.setLastTransactionIsolationLevel(level);
+ connection.setTransactionIsolation(level);
+ managedConnectionImpl.setLastTransactionIsolationLevel(level);
}
-
/**
* Checks the validity of this object
*/
protected void checkValidity() throws SQLException {
- if (isClosed) throw new SQLException("Connection closed");
- if (!valid) throw new SQLException("Invalid Connection");
+ if (isClosed) {
+ throw new SQLException("Connection closed");
+ }
+
+ if (!valid) {
+ throw new SQLException("Invalid Connection");
+ }
+
if (active == false) {
- mc.checkIfActive(this);
+ managedConnectionImpl.checkIfActive(this);
}
}
@@ -756,8 +777,8 @@
}
/*
- * Here this is a no-op. In the LazyEnlistableConnectionHolder, it will
- * actually fire the lazyEnlist method of LazyEnlistableManagedConnection
+ * Here this is a no-op. In the LazyEnlistableConnectionHolder, it will actually
+ * fire the lazyEnlist method of LazyEnlistableManagedConnection
*/
protected void jdbcPreInvoke() throws SQLException {
if (myType_ == ConnectionType.LAZY_ASSOCIATABLE) {
@@ -770,13 +791,11 @@
protected void performLazyEnlistment() throws SQLException {
try {
- if(lazyEnlistCm_ != null) {
- lazyEnlistCm_.lazyEnlist(mc);
+ if (lazyEnlistCm_ != null) {
+ lazyEnlistCm_.lazyEnlist(managedConnectionImpl);
}
} catch (ResourceException re) {
- String msg = sm.getString(
- "jdbc.cannot_enlist", re.getMessage() +
- " Cannnot Enlist ManagedConnection");
+ String msg = sm.getString("jdbc.cannot_enlist", re.getMessage() + " Cannnot Enlist ManagedConnection");
SQLException sqle = new SQLException(msg);
sqle.initCause(re);
@@ -786,15 +805,14 @@
}
protected void performLazyAssociation() throws SQLException {
- if (mc == null) {
+ if (managedConnectionImpl == null) {
try {
- if(lazyAssocCm_ != null) {
- lazyAssocCm_.associateConnection(this, mcf_, cxReqInfo_);
+ if (lazyAssocCm_ != null) {
+ lazyAssocCm_.associateConnection(this, managedConnectionFactory, connectionRequestInfo);
}
} catch (ResourceException re) {
- String msg = sm.getString(
- "jdbc.cannot_assoc", re.getMessage() +
- " Cannnot Associate ManagedConnection");
+ String msg = sm.getString("jdbc.cannot_assoc",
+ re.getMessage() + " Cannnot Associate ManagedConnection");
SQLException sqle = new SQLException(msg);
sqle.initCause(re);
@@ -811,24 +829,14 @@
return myType_;
}
- public void setLazyAssociatableConnectionManager(
- jakarta.resource.spi.LazyAssociatableConnectionManager cm) {
-
+ public void setLazyAssociatableConnectionManager(jakarta.resource.spi.LazyAssociatableConnectionManager cm) {
lazyAssocCm_ = cm;
}
- public void setLazyEnlistableConnectionManager(
- jakarta.resource.spi.LazyEnlistableConnectionManager cm) {
-
+ public void setLazyEnlistableConnectionManager(jakarta.resource.spi.LazyEnlistableConnectionManager cm) {
lazyEnlistCm_ = cm;
}
-/*
- public void setManagedConnection(ManagedConnection con) {
- this.mc = con;
- }
-*/
-
/**
* Installs the given <code>Map</code> object as the tyoe map for this
* <code> Connection </code> object.
@@ -838,7 +846,7 @@
*/
public void setTypeMap(java.util.Map<String, Class<?>> map) throws SQLException {
checkValidity();
- con.setTypeMap(map);
+ connection.setTypeMap(map);
}
protected MethodExecutor getMethodExecutor() {
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionWrapper.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionWrapper.java
index 155eca2..8e8f3e9 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionWrapper.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ConnectionWrapper.java
@@ -16,7 +16,6 @@
package com.sun.gjc.spi.base;
-
import java.sql.SQLException;
/**
@@ -24,26 +23,17 @@
* @author Shalini M
*/
public interface ConnectionWrapper {
- PreparedStatementWrapper prepareCachedStatement(String sql, int resultSetType,
- int resultSetConcurrency, boolean enableCaching) throws SQLException;
+ PreparedStatementWrapper prepareCachedStatement(String sql, int resultSetType, int resultSetConcurrency, boolean enableCaching) throws SQLException;
- PreparedStatementWrapper prepareCachedStatement(String sql, int resultSetType,
- int resultSetConcurrency, int resultSetHoldability,
- boolean enableCaching) throws SQLException;
+ PreparedStatementWrapper prepareCachedStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, boolean enableCaching) throws SQLException;
- PreparedStatementWrapper prepareCachedStatement(String sql,
- String[] columnNames, boolean enableCaching) throws SQLException;
+ PreparedStatementWrapper prepareCachedStatement(String sql, String[] columnNames, boolean enableCaching) throws SQLException;
- PreparedStatementWrapper prepareCachedStatement(String sql,
- int[] columnIndexes, boolean enableCaching) throws SQLException;
+ PreparedStatementWrapper prepareCachedStatement(String sql, int[] columnIndexes, boolean enableCaching) throws SQLException;
- PreparedStatementWrapper prepareCachedStatement(String sql,
- int autoGeneratedKeys, boolean enableCaching) throws SQLException;
+ PreparedStatementWrapper prepareCachedStatement(String sql, int autoGeneratedKeys, boolean enableCaching) throws SQLException;
- CallableStatementWrapper callableCachedStatement(String sql, int resultSetType,
- int resultSetConcurrency, boolean enableCaching) throws SQLException;
+ CallableStatementWrapper callableCachedStatement(String sql, int resultSetType, int resultSetConcurrency, boolean enableCaching) throws SQLException;
- CallableStatementWrapper callableCachedStatement(String sql, int resultSetType,
- int resultSetConcurrency, int resultSetHoldability,
- boolean enableCaching) throws SQLException;
+ CallableStatementWrapper callableCachedStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, boolean enableCaching) throws SQLException;
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/DatabaseMetaDataWrapper.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/DatabaseMetaDataWrapper.java
index 7fcea7b..f9f56fe 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/DatabaseMetaDataWrapper.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/DatabaseMetaDataWrapper.java
@@ -16,32 +16,30 @@
package com.sun.gjc.spi.base;
-import com.sun.gjc.util.MethodExecutor;
-import com.sun.logging.LogDomains;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Logger;
+import com.sun.gjc.util.MethodExecutor;
+import com.sun.logging.LogDomains;
+
/**
* Abstract class for wrapping DatabaseMetaData<br>
*/
public abstract class DatabaseMetaDataWrapper implements DatabaseMetaData {
- protected DatabaseMetaData databaseMetaData = null;
- protected Connection connection = null;
- private MethodExecutor executor = null;
- protected final static Logger _logger;
+ protected final static Logger _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- static {
- _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- }
+ protected DatabaseMetaData databaseMetaData;
+ protected Connection connection;
+ private MethodExecutor executor;
/**
* Abstract class for wrapping DatabaseMetaData
*
- * @param con Connection that is wrapped.<br>
+ * @param con Connection that is wrapped.<br>
* @param metaData DatabaseMetaData that is wrapped <br>
*/
public DatabaseMetaDataWrapper(Connection con, DatabaseMetaData metaData) {
@@ -51,8 +49,8 @@
}
/**
- * Retrieves whether the current user can call all the procedures
- * returned by the method <code>getProcedures</code>.
+ * Retrieves whether the current user can call all the procedures returned by
+ * the method <code>getProcedures</code>.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -62,9 +60,8 @@
}
/**
- * Retrieves whether the current user can use all the tables returned
- * by the method <code>getTables</code> in a <code>SELECT</code>
- * statement.
+ * Retrieves whether the current user can use all the tables returned by the
+ * method <code>getTables</code> in a <code>SELECT</code> statement.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -76,8 +73,7 @@
/**
* Retrieves the URL for this DBMS.
*
- * @return the URL for this DBMS or <code>null</code> if it cannot be
- * generated
+ * @return the URL for this DBMS or <code>null</code> if it cannot be generated
* @throws java.sql.SQLException if a database access error occurs
*/
public String getURL() throws SQLException {
@@ -105,11 +101,10 @@
}
/**
- * Retrieves whether <code>NULL</code> values are sorted high.
- * Sorted high means that <code>NULL</code> values
- * sort higher than any other value in a domain. In an ascending order,
- * if this method returns <code>true</code>, <code>NULL</code> values
- * will appear at the end. By contrast, the method
+ * Retrieves whether <code>NULL</code> values are sorted high. Sorted high means
+ * that <code>NULL</code> values sort higher than any other value in a domain.
+ * In an ascending order, if this method returns <code>true</code>,
+ * <code>NULL</code> values will appear at the end. By contrast, the method
* <code>nullsAreSortedAtEnd</code> indicates whether <code>NULL</code> values
* are sorted at the end regardless of sort order.
*
@@ -121,13 +116,12 @@
}
/**
- * Retrieves whether <code>NULL</code> values are sorted low.
- * Sorted low means that <code>NULL</code> values
- * sort lower than any other value in a domain. In an ascending order,
- * if this method returns <code>true</code>, <code>NULL</code> values
- * will appear at the beginning. By contrast, the method
- * <code>nullsAreSortedAtStart</code> indicates whether <code>NULL</code> values
- * are sorted at the beginning regardless of sort order.
+ * Retrieves whether <code>NULL</code> values are sorted low. Sorted low means
+ * that <code>NULL</code> values sort lower than any other value in a domain. In
+ * an ascending order, if this method returns <code>true</code>,
+ * <code>NULL</code> values will appear at the beginning. By contrast, the
+ * method <code>nullsAreSortedAtStart</code> indicates whether <code>NULL</code>
+ * values are sorted at the beginning regardless of sort order.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -148,8 +142,8 @@
}
/**
- * Retrieves whether <code>NULL</code> values are sorted at the end regardless of
- * sort order.
+ * Retrieves whether <code>NULL</code> values are sorted at the end regardless
+ * of sort order.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -230,7 +224,7 @@
* Retrieves whether this database uses a file for each table.
*
* @return <code>true</code> if this database uses a local file for each table;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean usesLocalFilePerTable() throws SQLException {
@@ -326,8 +320,8 @@
}
/**
- * Retrieves the string used to quote SQL identifiers.
- * This method returns a space " " if identifier quoting is not supported.
+ * Retrieves the string used to quote SQL identifiers. This method returns a
+ * space " " if identifier quoting is not supported.
*
* @return the quoting string or a space if quoting is not supported
* @throws java.sql.SQLException if a database access error occurs
@@ -337,11 +331,10 @@
}
/**
- * Retrieves a comma-separated list of all of this database's SQL keywords
- * that are NOT also SQL92 keywords.
+ * Retrieves a comma-separated list of all of this database's SQL keywords that
+ * are NOT also SQL92 keywords.
*
- * @return the list of this database's keywords that are not also
- * SQL92 keywords
+ * @return the list of this database's keywords that are not also SQL92 keywords
* @throws java.sql.SQLException if a database access error occurs
*/
public String getSQLKeywords() throws SQLException {
@@ -349,9 +342,9 @@
}
/**
- * Retrieves a comma-separated list of math functions available with
- * this database. These are the Open /Open CLI math function names used in
- * the JDBC function escape clause.
+ * Retrieves a comma-separated list of math functions available with this
+ * database. These are the Open /Open CLI math function names used in the JDBC
+ * function escape clause.
*
* @return the list of math functions supported by this database
* @throws java.sql.SQLException if a database access error occurs
@@ -361,9 +354,9 @@
}
/**
- * Retrieves a comma-separated list of string functions available with
- * this database. These are the Open Group CLI string function names used
- * in the JDBC function escape clause.
+ * Retrieves a comma-separated list of string functions available with this
+ * database. These are the Open Group CLI string function names used in the JDBC
+ * function escape clause.
*
* @return the list of string functions supported by this database
* @throws java.sql.SQLException if a database access error occurs
@@ -373,9 +366,9 @@
}
/**
- * Retrieves a comma-separated list of system functions available with
- * this database. These are the Open Group CLI system function names used
- * in the JDBC function escape clause.
+ * Retrieves a comma-separated list of system functions available with this
+ * database. These are the Open Group CLI system function names used in the JDBC
+ * function escape clause.
*
* @return a list of system functions supported by this database
* @throws java.sql.SQLException if a database access error occurs
@@ -396,14 +389,14 @@
}
/**
- * Retrieves the string that can be used to escape wildcard characters.
- * This is the string that can be used to escape '_' or '%' in
- * the catalog search parameters that are a pattern (and therefore use one
- * of the wildcard characters).
+ * Retrieves the string that can be used to escape wildcard characters. This is
+ * the string that can be used to escape '_' or '%' in the catalog search
+ * parameters that are a pattern (and therefore use one of the wildcard
+ * characters).
* <p/>
- * <P>The '_' character represents any single character;
- * the '%' character represents any sequence of zero or
- * more characters.
+ * <P>
+ * The '_' character represents any single character; the '%' character
+ * represents any sequence of zero or more characters.
*
* @return the string used to escape wildcard characters
* @throws java.sql.SQLException if a database access error occurs
@@ -413,8 +406,8 @@
}
/**
- * Retrieves all the "extra" characters that can be used in unquoted
- * identifier names (those beyond a-z, A-Z, 0-9 and _).
+ * Retrieves all the "extra" characters that can be used in unquoted identifier
+ * names (those beyond a-z, A-Z, 0-9 and _).
*
* @return the string containing the extra characters
* @throws java.sql.SQLException if a database access error occurs
@@ -424,8 +417,8 @@
}
/**
- * Retrieves whether this database supports <code>ALTER TABLE</code>
- * with add column.
+ * Retrieves whether this database supports <code>ALTER TABLE</code> with add
+ * column.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -435,8 +428,8 @@
}
/**
- * Retrieves whether this database supports <code>ALTER TABLE</code>
- * with drop column.
+ * Retrieves whether this database supports <code>ALTER TABLE</code> with drop
+ * column.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -448,9 +441,9 @@
/**
* Retrieves whether this database supports column aliasing.
* <p/>
- * <P>If so, the SQL AS clause can be used to provide names for
- * computed columns or to provide alias names for columns as
- * required.
+ * <P>
+ * If so, the SQL AS clause can be used to provide names for computed columns or
+ * to provide alias names for columns as required.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -461,8 +454,7 @@
/**
* Retrieves whether this database supports concatenations between
- * <code>NULL</code> and non-<code>NULL</code> values being
- * <code>NULL</code>.
+ * <code>NULL</code> and non-<code>NULL</code> values being <code>NULL</code>.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -472,8 +464,8 @@
}
/**
- * Retrieves whether this database supports the <code>CONVERT</code>
- * function between SQL types.
+ * Retrieves whether this database supports the <code>CONVERT</code> function
+ * between SQL types.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -483,13 +475,13 @@
}
/**
- * Retrieves whether this database supports the <code>CONVERT</code>
- * for two given SQL types.
+ * Retrieves whether this database supports the <code>CONVERT</code> for two
+ * given SQL types.
*
- * @param fromType the type to convert from; one of the type codes from
- * the class <code>java.sql.Types</code>
- * @param toType the type to convert to; one of the type codes from
- * the class <code>java.sql.Types</code>
+ * @param fromType the type to convert from; one of the type codes from the
+ * class <code>java.sql.Types</code>
+ * @param toType the type to convert to; one of the type codes from the class
+ * <code>java.sql.Types</code>
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Types
@@ -509,8 +501,8 @@
}
/**
- * Retrieves whether, when table correlation names are supported, they
- * are restricted to being different from the names of the tables.
+ * Retrieves whether, when table correlation names are supported, they are
+ * restricted to being different from the names of the tables.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -520,8 +512,8 @@
}
/**
- * Retrieves whether this database supports expressions in
- * <code>ORDER BY</code> lists.
+ * Retrieves whether this database supports expressions in <code>ORDER BY</code>
+ * lists.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -531,9 +523,8 @@
}
/**
- * Retrieves whether this database supports using a column that is
- * not in the <code>SELECT</code> statement in an
- * <code>ORDER BY</code> clause.
+ * Retrieves whether this database supports using a column that is not in the
+ * <code>SELECT</code> statement in an <code>ORDER BY</code> clause.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -543,8 +534,8 @@
}
/**
- * Retrieves whether this database supports some form of
- * <code>GROUP BY</code> clause.
+ * Retrieves whether this database supports some form of <code>GROUP BY</code>
+ * clause.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -554,9 +545,8 @@
}
/**
- * Retrieves whether this database supports using a column that is
- * not in the <code>SELECT</code> statement in a
- * <code>GROUP BY</code> clause.
+ * Retrieves whether this database supports using a column that is not in the
+ * <code>SELECT</code> statement in a <code>GROUP BY</code> clause.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -566,10 +556,10 @@
}
/**
- * Retrieves whether this database supports using columns not included in
- * the <code>SELECT</code> statement in a <code>GROUP BY</code> clause
- * provided that all of the columns in the <code>SELECT</code> statement
- * are included in the <code>GROUP BY</code> clause.
+ * Retrieves whether this database supports using columns not included in the
+ * <code>SELECT</code> statement in a <code>GROUP BY</code> clause provided that
+ * all of the columns in the <code>SELECT</code> statement are included in the
+ * <code>GROUP BY</code> clause.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -579,8 +569,8 @@
}
/**
- * Retrieves whether this database supports specifying a
- * <code>LIKE</code> escape clause.
+ * Retrieves whether this database supports specifying a <code>LIKE</code>
+ * escape clause.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -591,8 +581,8 @@
/**
* Retrieves whether this database supports getting multiple
- * <code>ResultSet</code> objects from a single call to the
- * method <code>execute</code>.
+ * <code>ResultSet</code> objects from a single call to the method
+ * <code>execute</code>.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -602,8 +592,8 @@
}
/**
- * Retrieves whether this database allows having multiple
- * transactions open at once (on different connections).
+ * Retrieves whether this database allows having multiple transactions open at
+ * once (on different connections).
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -653,8 +643,7 @@
}
/**
- * Retrieves whether this database supports the ANSI92 entry level SQL
- * grammar.
+ * Retrieves whether this database supports the ANSI92 entry level SQL grammar.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -664,7 +653,8 @@
}
/**
- * Retrieves whether this database supports the ANSI92 intermediate SQL grammar supported.
+ * Retrieves whether this database supports the ANSI92 intermediate SQL grammar
+ * supported.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -674,7 +664,8 @@
}
/**
- * Retrieves whether this database supports the ANSI92 full SQL grammar supported.
+ * Retrieves whether this database supports the ANSI92 full SQL grammar
+ * supported.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -684,8 +675,8 @@
}
/**
- * Retrieves whether this database supports the SQL Integrity
- * Enhancement Facility.
+ * Retrieves whether this database supports the SQL Integrity Enhancement
+ * Facility.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -715,8 +706,8 @@
}
/**
- * Retrieves whether this database provides limited support for outer
- * joins. (This will be <code>true</code> if the method
+ * Retrieves whether this database provides limited support for outer joins.
+ * (This will be <code>true</code> if the method
* <code>supportsFullOuterJoins</code> returns <code>true</code>).
*
* @return <code>true</code> if so; <code>false</code> otherwise
@@ -757,11 +748,11 @@
}
/**
- * Retrieves whether a catalog appears at the start of a fully qualified
- * table name. If not, the catalog appears at the end.
+ * Retrieves whether a catalog appears at the start of a fully qualified table
+ * name. If not, the catalog appears at the end.
*
- * @return <code>true</code> if the catalog name appears at the beginning
- * of a fully qualified table name; <code>false</code> otherwise
+ * @return <code>true</code> if the catalog name appears at the beginning of a
+ * fully qualified table name; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean isCatalogAtStart() throws SQLException {
@@ -769,8 +760,8 @@
}
/**
- * Retrieves the <code>String</code> that this database uses as the
- * separator between a catalog and table name.
+ * Retrieves the <code>String</code> that this database uses as the separator
+ * between a catalog and table name.
*
* @return the separator string
* @throws java.sql.SQLException if a database access error occurs
@@ -820,7 +811,8 @@
}
/**
- * Retrieves whether a schema name can be used in a privilege definition statement.
+ * Retrieves whether a schema name can be used in a privilege definition
+ * statement.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -830,7 +822,8 @@
}
/**
- * Retrieves whether a catalog name can be used in a data manipulation statement.
+ * Retrieves whether a catalog name can be used in a data manipulation
+ * statement.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -860,7 +853,8 @@
}
/**
- * Retrieves whether a catalog name can be used in an index definition statement.
+ * Retrieves whether a catalog name can be used in an index definition
+ * statement.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -870,7 +864,8 @@
}
/**
- * Retrieves whether a catalog name can be used in a privilege definition statement.
+ * Retrieves whether a catalog name can be used in a privilege definition
+ * statement.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -913,8 +908,8 @@
}
/**
- * Retrieves whether this database supports stored procedure calls
- * that use the stored procedure escape syntax.
+ * Retrieves whether this database supports stored procedure calls that use the
+ * stored procedure escape syntax.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -935,8 +930,8 @@
}
/**
- * Retrieves whether this database supports subqueries in
- * <code>EXISTS</code> expressions.
+ * Retrieves whether this database supports subqueries in <code>EXISTS</code>
+ * expressions.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -946,8 +941,8 @@
}
/**
- * Retrieves whether this database supports subqueries in
- * <code>IN</code> statements.
+ * Retrieves whether this database supports subqueries in <code>IN</code>
+ * statements.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -998,11 +993,10 @@
}
/**
- * Retrieves whether this database supports keeping cursors open
- * across commits.
+ * Retrieves whether this database supports keeping cursors open across commits.
*
- * @return <code>true</code> if cursors always remain open;
- * <code>false</code> if they might not remain open
+ * @return <code>true</code> if cursors always remain open; <code>false</code>
+ * if they might not remain open
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
@@ -1010,11 +1004,11 @@
}
/**
- * Retrieves whether this database supports keeping cursors open
- * across rollbacks.
+ * Retrieves whether this database supports keeping cursors open across
+ * rollbacks.
*
- * @return <code>true</code> if cursors always remain open;
- * <code>false</code> if they might not remain open
+ * @return <code>true</code> if cursors always remain open; <code>false</code>
+ * if they might not remain open
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
@@ -1022,11 +1016,11 @@
}
/**
- * Retrieves whether this database supports keeping statements open
- * across commits.
+ * Retrieves whether this database supports keeping statements open across
+ * commits.
*
* @return <code>true</code> if statements always remain open;
- * <code>false</code> if they might not remain open
+ * <code>false</code> if they might not remain open
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
@@ -1034,11 +1028,11 @@
}
/**
- * Retrieves whether this database supports keeping statements open
- * across rollbacks.
+ * Retrieves whether this database supports keeping statements open across
+ * rollbacks.
*
* @return <code>true</code> if statements always remain open;
- * <code>false</code> if they might not remain open
+ * <code>false</code> if they might not remain open
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
@@ -1049,9 +1043,8 @@
* Retrieves the maximum number of hex characters this database allows in an
* inline binary literal.
*
- * @return max the maximum length (in hex characters) for a binary literal;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return max the maximum length (in hex characters) for a binary literal; a
+ * result of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxBinaryLiteralLength() throws SQLException {
@@ -1059,12 +1052,11 @@
}
/**
- * Retrieves the maximum number of characters this database allows
- * for a character literal.
+ * Retrieves the maximum number of characters this database allows for a
+ * character literal.
*
- * @return the maximum number of characters allowed for a character literal;
- * a result of zero means that there is no limit or the limit is
- * not known
+ * @return the maximum number of characters allowed for a character literal; a
+ * result of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxCharLiteralLength() throws SQLException {
@@ -1072,12 +1064,11 @@
}
/**
- * Retrieves the maximum number of characters this database allows
- * for a column name.
+ * Retrieves the maximum number of characters this database allows for a column
+ * name.
*
- * @return the maximum number of characters allowed for a column name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed for a column name; a result
+ * of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxColumnNameLength() throws SQLException {
@@ -1088,9 +1079,8 @@
* Retrieves the maximum number of columns this database allows in a
* <code>GROUP BY</code> clause.
*
- * @return the maximum number of columns allowed;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of columns allowed; a result of zero means that
+ * there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxColumnsInGroupBy() throws SQLException {
@@ -1100,9 +1090,8 @@
/**
* Retrieves the maximum number of columns this database allows in an index.
*
- * @return the maximum number of columns allowed;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of columns allowed; a result of zero means that
+ * there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxColumnsInIndex() throws SQLException {
@@ -1113,9 +1102,8 @@
* Retrieves the maximum number of columns this database allows in an
* <code>ORDER BY</code> clause.
*
- * @return the maximum number of columns allowed;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of columns allowed; a result of zero means that
+ * there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxColumnsInOrderBy() throws SQLException {
@@ -1126,9 +1114,8 @@
* Retrieves the maximum number of columns this database allows in a
* <code>SELECT</code> list.
*
- * @return the maximum number of columns allowed;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of columns allowed; a result of zero means that
+ * there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxColumnsInSelect() throws SQLException {
@@ -1138,9 +1125,8 @@
/**
* Retrieves the maximum number of columns this database allows in a table.
*
- * @return the maximum number of columns allowed;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of columns allowed; a result of zero means that
+ * there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxColumnsInTable() throws SQLException {
@@ -1148,12 +1134,11 @@
}
/**
- * Retrieves the maximum number of concurrent connections to this
- * database that are possible.
+ * Retrieves the maximum number of concurrent connections to this database that
+ * are possible.
*
- * @return the maximum number of active connections possible at one time;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of active connections possible at one time; a
+ * result of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxConnections() throws SQLException {
@@ -1164,9 +1149,8 @@
* Retrieves the maximum number of characters that this database allows in a
* cursor name.
*
- * @return the maximum number of characters allowed in a cursor name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed in a cursor name; a result
+ * of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxCursorNameLength() throws SQLException {
@@ -1174,13 +1158,12 @@
}
/**
- * Retrieves the maximum number of bytes this database allows for an
- * index, including all of the parts of the index.
+ * Retrieves the maximum number of bytes this database allows for an index,
+ * including all of the parts of the index.
*
* @return the maximum number of bytes allowed; this limit includes the
- * composite of all the constituent parts of the index;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * composite of all the constituent parts of the index; a result of zero means
+ * that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxIndexLength() throws SQLException {
@@ -1191,9 +1174,8 @@
* Retrieves the maximum number of characters that this database allows in a
* schema name.
*
- * @return the maximum number of characters allowed in a schema name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed in a schema name; a result
+ * of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxSchemaNameLength() throws SQLException {
@@ -1204,9 +1186,8 @@
* Retrieves the maximum number of characters that this database allows in a
* procedure name.
*
- * @return the maximum number of characters allowed in a procedure name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed in a procedure name; a
+ * result of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxProcedureNameLength() throws SQLException {
@@ -1217,9 +1198,8 @@
* Retrieves the maximum number of characters that this database allows in a
* catalog name.
*
- * @return the maximum number of characters allowed in a catalog name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed in a catalog name; a result
+ * of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxCatalogNameLength() throws SQLException {
@@ -1227,11 +1207,10 @@
}
/**
- * Retrieves the maximum number of bytes this database allows in
- * a single row.
+ * Retrieves the maximum number of bytes this database allows in a single row.
*
- * @return the maximum number of bytes allowed for a row; a result of
- * zero means that there is no limit or the limit is not known
+ * @return the maximum number of bytes allowed for a row; a result of zero means
+ * that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxRowSize() throws SQLException {
@@ -1239,9 +1218,9 @@
}
/**
- * Retrieves whether the return value for the method
- * <code>getMaxRowSize</code> includes the SQL data types
- * <code>LONGVARCHAR</code> and <code>LONGVARBINARY</code>.
+ * Retrieves whether the return value for the method <code>getMaxRowSize</code>
+ * includes the SQL data types <code>LONGVARCHAR</code> and
+ * <code>LONGVARBINARY</code>.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -1251,12 +1230,11 @@
}
/**
- * Retrieves the maximum number of characters this database allows in
- * an SQL statement.
+ * Retrieves the maximum number of characters this database allows in an SQL
+ * statement.
*
- * @return the maximum number of characters allowed for an SQL statement;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed for an SQL statement; a
+ * result of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxStatementLength() throws SQLException {
@@ -1264,12 +1242,11 @@
}
/**
- * Retrieves the maximum number of active statements to this database
- * that can be open at the same time.
+ * Retrieves the maximum number of active statements to this database that can
+ * be open at the same time.
*
- * @return the maximum number of statements that can be open at one time;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of statements that can be open at one time; a
+ * result of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxStatements() throws SQLException {
@@ -1277,12 +1254,11 @@
}
/**
- * Retrieves the maximum number of characters this database allows in
- * a table name.
+ * Retrieves the maximum number of characters this database allows in a table
+ * name.
*
- * @return the maximum number of characters allowed for a table name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed for a table name; a result
+ * of zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxTableNameLength() throws SQLException {
@@ -1294,8 +1270,8 @@
* <code>SELECT</code> statement.
*
* @return the maximum number of tables allowed in a <code>SELECT</code>
- * statement; a result of zero means that there is no limit or
- * the limit is not known
+ * statement; a result of zero means that there is no limit or the limit is not
+ * known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxTablesInSelect() throws SQLException {
@@ -1303,12 +1279,11 @@
}
/**
- * Retrieves the maximum number of characters this database allows in
- * a user name.
+ * Retrieves the maximum number of characters this database allows in a user
+ * name.
*
- * @return the maximum number of characters allowed for a user name;
- * a result of zero means that there is no limit or the limit
- * is not known
+ * @return the maximum number of characters allowed for a user name; a result of
+ * zero means that there is no limit or the limit is not known
* @throws java.sql.SQLException if a database access error occurs
*/
public int getMaxUserNameLength() throws SQLException {
@@ -1316,8 +1291,8 @@
}
/**
- * Retrieves this database's default transaction isolation level. The
- * possible values are defined in <code>java.sql.Connection</code>.
+ * Retrieves this database's default transaction isolation level. The possible
+ * values are defined in <code>java.sql.Connection</code>.
*
* @return the default isolation level
* @throws java.sql.SQLException if a database access error occurs
@@ -1332,8 +1307,8 @@
* method <code>commit</code> is a noop, and the isolation level is
* <code>TRANSACTION_NONE</code>.
*
- * @return <code>true</code> if transactions are supported;
- * <code>false</code> otherwise
+ * @return <code>true</code> if transactions are supported; <code>false</code>
+ * otherwise
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean supportsTransactions() throws SQLException {
@@ -1341,10 +1316,11 @@
}
/**
- * Retrieves whether this database supports the given transaction isolation level.
+ * Retrieves whether this database supports the given transaction isolation
+ * level.
*
* @param level one of the transaction isolation levels defined in
- * <code>java.sql.Connection</code>
+ * <code>java.sql.Connection</code>
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Connection
@@ -1354,8 +1330,8 @@
}
/**
- * Retrieves whether this database supports both data definition and
- * data manipulation statements within a transaction.
+ * Retrieves whether this database supports both data definition and data
+ * manipulation statements within a transaction.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -1365,8 +1341,8 @@
}
/**
- * Retrieves whether this database supports only data manipulation
- * statements within a transaction.
+ * Retrieves whether this database supports only data manipulation statements
+ * within a transaction.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -1376,8 +1352,8 @@
}
/**
- * Retrieves whether a data definition statement within a transaction forces
- * the transaction to commit.
+ * Retrieves whether a data definition statement within a transaction forces the
+ * transaction to commit.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -1387,8 +1363,8 @@
}
/**
- * Retrieves whether this database ignores a data definition statement
- * within a transaction.
+ * Retrieves whether this database ignores a data definition statement within a
+ * transaction.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -1401,119 +1377,122 @@
* Retrieves a description of the stored procedures available in the given
* catalog.
* <p/>
- * Only procedure descriptions matching the schema and
- * procedure name criteria are returned. They are ordered by
- * <code>PROCEDURE_SCHEM</code> and <code>PROCEDURE_NAME</code>.
+ * Only procedure descriptions matching the schema and procedure name criteria
+ * are returned. They are ordered by <code>PROCEDURE_SCHEM</code> and
+ * <code>PROCEDURE_NAME</code>.
* <p/>
- * <P>Each procedure description has the the following columns:
+ * <P>
+ * Each procedure description has the the following columns:
* <OL>
- * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be <code>null</code>)
- * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be <code>null</code>)
+ * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be
+ * <code>null</code>)
+ * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be
+ * <code>null</code>)
* <LI><B>PROCEDURE_NAME</B> String => procedure name
- * <LI> reserved for future use
- * <LI> reserved for future use
- * <LI> reserved for future use
+ * <LI>reserved for future use
+ * <LI>reserved for future use
+ * <LI>reserved for future use
* <LI><B>REMARKS</B> String => explanatory comment on the procedure
* <LI><B>PROCEDURE_TYPE</B> short => kind of procedure:
* <UL>
- * <LI> procedureResultUnknown - May return a result
- * <LI> procedureNoResult - Does not return a result
- * <LI> procedureReturnsResult - Returns a result
+ * <LI>procedureResultUnknown - May return a result
+ * <LI>procedureNoResult - Does not return a result
+ * <LI>procedureReturnsResult - Returns a result
* </UL>
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
* @param procedureNamePattern a procedure name pattern; must match the
- * procedure name as it is stored in the database
+ * procedure name as it is stored in the database
* @return <code>ResultSet</code> - each row is a procedure description
* @throws java.sql.SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
- public ResultSet getProcedures(String catalog, String schemaPattern,
- String procedureNamePattern) throws SQLException {
+ public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
+ throws SQLException {
return databaseMetaData.getProcedures(catalog, schemaPattern, procedureNamePattern);
}
/**
- * Retrieves a description of the given catalog's stored procedure parameter
- * and result columns.
+ * Retrieves a description of the given catalog's stored procedure parameter and
+ * result columns.
* <p/>
- * <P>Only descriptions matching the schema, procedure and
- * parameter name criteria are returned. They are ordered by
- * PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value,
- * if any, is first. Next are the parameter descriptions in call
- * order. The column descriptions follow in column number order.
+ * <P>
+ * Only descriptions matching the schema, procedure and parameter name criteria
+ * are returned. They are ordered by PROCEDURE_SCHEM and PROCEDURE_NAME. Within
+ * this, the return value, if any, is first. Next are the parameter descriptions
+ * in call order. The column descriptions follow in column number order.
* <p/>
- * <P>Each row in the <code>ResultSet</code> is a parameter description or
- * column description with the following fields:
+ * <P>
+ * Each row in the <code>ResultSet</code> is a parameter description or column
+ * description with the following fields:
* <OL>
- * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be <code>null</code>)
- * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be <code>null</code>)
+ * <LI><B>PROCEDURE_CAT</B> String => procedure catalog (may be
+ * <code>null</code>)
+ * <LI><B>PROCEDURE_SCHEM</B> String => procedure schema (may be
+ * <code>null</code>)
* <LI><B>PROCEDURE_NAME</B> String => procedure name
* <LI><B>COLUMN_NAME</B> String => column/parameter name
* <LI><B>COLUMN_TYPE</B> Short => kind of column/parameter:
* <UL>
- * <LI> procedureColumnUnknown - nobody knows
- * <LI> procedureColumnIn - IN parameter
- * <LI> procedureColumnInOut - INOUT parameter
- * <LI> procedureColumnOut - OUT parameter
- * <LI> procedureColumnReturn - procedure return value
- * <LI> procedureColumnResult - result column in <code>ResultSet</code>
+ * <LI>procedureColumnUnknown - nobody knows
+ * <LI>procedureColumnIn - IN parameter
+ * <LI>procedureColumnInOut - INOUT parameter
+ * <LI>procedureColumnOut - OUT parameter
+ * <LI>procedureColumnReturn - procedure return value
+ * <LI>procedureColumnResult - result column in <code>ResultSet</code>
* </UL>
* <LI><B>DATA_TYPE</B> int => SQL type from java.sql.Types
- * <LI><B>TYPE_NAME</B> String => SQL type name, for a UDT type the
- * type name is fully qualified
+ * <LI><B>TYPE_NAME</B> String => SQL type name, for a UDT type the type name is
+ * fully qualified
* <LI><B>PRECISION</B> int => precision
* <LI><B>LENGTH</B> int => length in bytes of data
* <LI><B>SCALE</B> short => scale
* <LI><B>RADIX</B> short => radix
* <LI><B>NULLABLE</B> short => can it contain NULL.
* <UL>
- * <LI> procedureNoNulls - does not allow NULL values
- * <LI> procedureNullable - allows NULL values
- * <LI> procedureNullableUnknown - nullability unknown
+ * <LI>procedureNoNulls - does not allow NULL values
+ * <LI>procedureNullable - allows NULL values
+ * <LI>procedureNullableUnknown - nullability unknown
* </UL>
* <LI><B>REMARKS</B> String => comment describing parameter/column
* </OL>
* <p/>
- * <P><B>Note:</B> Some databases may not return the column
- * descriptions for a procedure. Additional columns beyond
- * REMARKS can be defined by the database.
+ * <P>
+ * <B>Note:</B> Some databases may not return the column descriptions for a
+ * procedure. Additional columns beyond REMARKS can be defined by the database.
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
* @param procedureNamePattern a procedure name pattern; must match the
- * procedure name as it is stored in the database
- * @param columnNamePattern a column name pattern; must match the column name
- * as it is stored in the database
- * @return <code>ResultSet</code> - each row describes a stored procedure parameter or
- * column
+ * procedure name as it is stored in the database
+ * @param columnNamePattern a column name pattern; must match the column name as
+ * it is stored in the database
+ * @return <code>ResultSet</code> - each row describes a stored procedure
+ * parameter or column
* @throws java.sql.SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
- String columnNamePattern) throws SQLException {
+ String columnNamePattern) throws SQLException {
return databaseMetaData.getProcedureColumns(catalog, schemaPattern, procedureNamePattern, columnNamePattern);
}
/**
- * Retrieves a description of the tables available in the given catalog.
- * Only table descriptions matching the catalog, schema, table
- * name and type criteria are returned. They are ordered by
- * TABLE_TYPE, TABLE_SCHEM and TABLE_NAME.
+ * Retrieves a description of the tables available in the given catalog. Only
+ * table descriptions matching the catalog, schema, table name and type criteria
+ * are returned. They are ordered by TABLE_TYPE, TABLE_SCHEM and TABLE_NAME.
* <p/>
* Each table description has the following columns:
* <OL>
@@ -1521,7 +1500,8 @@
* <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
* <LI><B>TABLE_NAME</B> String => table name
* <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE",
- * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
+ * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS",
+ * "SYNONYM".
* <LI><B>REMARKS</B> String => explanatory comment on the table
* <LI><B>TYPE_CAT</B> String => the types catalog (may be <code>null</code>)
* <LI><B>TYPE_SCHEM</B> String => the types schema (may be <code>null</code>)
@@ -1529,45 +1509,46 @@
* <LI><B>SELF_REFERENCING_COL_NAME</B> String => name of the designated
* "identifier" column of a typed table (may be <code>null</code>)
* <LI><B>REF_GENERATION</B> String => specifies how values in
- * SELF_REFERENCING_COL_NAME are created. Values are
- * "SYSTEM", "USER", "DERIVED". (may be <code>null</code>)
+ * SELF_REFERENCING_COL_NAME are created. Values are "SYSTEM", "USER",
+ * "DERIVED". (may be <code>null</code>)
* </OL>
* <p/>
- * <P><B>Note:</B> Some databases may not return information for
- * all tables.
+ * <P>
+ * <B>Note:</B> Some databases may not return information for all tables.
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param tableNamePattern a table name pattern; must match the
- * table name as it is stored in the database
- * @param types a list of table types to include; <code>null</code> returns all types
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param tableNamePattern a table name pattern; must match the table name as it
+ * is stored in the database
+ * @param types a list of table types to include; <code>null</code> returns all
+ * types
* @return <code>ResultSet</code> - each row is a table description
* @throws java.sql.SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
- public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern,
- String types[]) throws SQLException {
+ public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[])
+ throws SQLException {
return databaseMetaData.getTables(catalog, schemaPattern, tableNamePattern, types);
}
/**
- * Retrieves the schema names available in this database. The results
- * are ordered by schema name.
+ * Retrieves the schema names available in this database. The results are
+ * ordered by schema name.
* <p/>
- * <P>The schema column is:
+ * <P>
+ * The schema column is:
* <OL>
* <LI><B>TABLE_SCHEM</B> String => schema name
* <LI><B>TABLE_CATALOG</B> String => catalog name (may be <code>null</code>)
* </OL>
*
- * @return a <code>ResultSet</code> object in which each row is a
- * schema decription
+ * @return a <code>ResultSet</code> object in which each row is a schema
+ * decription
* @throws java.sql.SQLException if a database access error occurs
*/
public ResultSet getSchemas() throws SQLException {
@@ -1575,16 +1556,17 @@
}
/**
- * Retrieves the catalog names available in this database. The results
- * are ordered by catalog name.
+ * Retrieves the catalog names available in this database. The results are
+ * ordered by catalog name.
* <p/>
- * <P>The catalog column is:
+ * <P>
+ * The catalog column is:
* <OL>
* <LI><B>TABLE_CAT</B> String => catalog name
* </OL>
*
- * @return a <code>ResultSet</code> object in which each row has a
- * single <code>String</code> column that is a catalog name
+ * @return a <code>ResultSet</code> object in which each row has a single
+ * <code>String</code> column that is a catalog name
* @throws java.sql.SQLException if a database access error occurs
*/
public ResultSet getCatalogs() throws SQLException {
@@ -1592,18 +1574,19 @@
}
/**
- * Retrieves the table types available in this database. The results
- * are ordered by table type.
+ * Retrieves the table types available in this database. The results are ordered
+ * by table type.
* <p/>
- * <P>The table type is:
+ * <P>
+ * The table type is:
* <OL>
- * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE",
- * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY",
- * "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
+ * <LI><B>TABLE_TYPE</B> String => table type. Typical types are "TABLE",
+ * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS",
+ * "SYNONYM".
* </OL>
*
- * @return a <code>ResultSet</code> object in which each row has a
- * single <code>String</code> column that is a table type
+ * @return a <code>ResultSet</code> object in which each row has a single
+ * <code>String</code> column that is a table type
* @throws java.sql.SQLException if a database access error occurs
*/
public ResultSet getTableTypes() throws SQLException {
@@ -1611,85 +1594,85 @@
}
/**
- * Retrieves a description of table columns available in
- * the specified catalog.
+ * Retrieves a description of table columns available in the specified catalog.
* <p/>
- * <P>Only column descriptions matching the catalog, schema, table
- * and column name criteria are returned. They are ordered by
- * <code>TABLE_SCHEM</code>, <code>TABLE_NAME</code>, and
- * <code>ORDINAL_POSITION</code>.
+ * <P>
+ * Only column descriptions matching the catalog, schema, table and column name
+ * criteria are returned. They are ordered by <code>TABLE_SCHEM</code>,
+ * <code>TABLE_NAME</code>, and <code>ORDINAL_POSITION</code>.
* <p/>
- * <P>Each column description has the following columns:
+ * <P>
+ * Each column description has the following columns:
* <OL>
* <LI><B>TABLE_CAT</B> String => table catalog (may be <code>null</code>)
* <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
* <LI><B>TABLE_NAME</B> String => table name
* <LI><B>COLUMN_NAME</B> String => column name
* <LI><B>DATA_TYPE</B> int => SQL type from java.sql.Types
- * <LI><B>TYPE_NAME</B> String => Data source dependent type name,
- * for a UDT the type name is fully qualified
- * <LI><B>COLUMN_SIZE</B> int => column size. For char or date
- * types this is the maximum number of characters, for numeric or
- * decimal types this is precision.
+ * <LI><B>TYPE_NAME</B> String => Data source dependent type name, for a UDT the
+ * type name is fully qualified
+ * <LI><B>COLUMN_SIZE</B> int => column size. For char or date types this is the
+ * maximum number of characters, for numeric or decimal types this is precision.
* <LI><B>BUFFER_LENGTH</B> is not used.
* <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits
* <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2)
* <LI><B>NULLABLE</B> int => is NULL allowed.
* <UL>
- * <LI> columnNoNulls - might not allow <code>NULL</code> values
- * <LI> columnNullable - definitely allows <code>NULL</code> values
- * <LI> columnNullableUnknown - nullability unknown
+ * <LI>columnNoNulls - might not allow <code>NULL</code> values
+ * <LI>columnNullable - definitely allows <code>NULL</code> values
+ * <LI>columnNullableUnknown - nullability unknown
* </UL>
- * <LI><B>REMARKS</B> String => comment describing column (may be <code>null</code>)
+ * <LI><B>REMARKS</B> String => comment describing column (may be
+ * <code>null</code>)
* <LI><B>COLUMN_DEF</B> String => default value (may be <code>null</code>)
* <LI><B>SQL_DATA_TYPE</B> int => unused
* <LI><B>SQL_DATETIME_SUB</B> int => unused
- * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the
- * maximum number of bytes in the column
- * <LI><B>ORDINAL_POSITION</B> int => index of column in table
- * (starting at 1)
- * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely
- * does not allow NULL values; "YES" means the column might
- * allow NULL values. An empty string means nobody knows.
- * <LI><B>SCOPE_CATLOG</B> String => catalog of table that is the scope
- * of a reference attribute (<code>null</code> if DATA_TYPE isn't REF)
- * <LI><B>SCOPE_SCHEMA</B> String => schema of table that is the scope
- * of a reference attribute (<code>null</code> if the DATA_TYPE isn't REF)
- * <LI><B>SCOPE_TABLE</B> String => table name that this the scope
- * of a reference attribure (<code>null</code> if the DATA_TYPE isn't REF)
- * <LI><B>SOURCE_DATA_TYPE</B> short => source type of a distinct type or user-generated
- * Ref type, SQL type from java.sql.Types (<code>null</code> if DATA_TYPE
- * isn't DISTINCT or user-generated REF)
+ * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the maximum number of
+ * bytes in the column
+ * <LI><B>ORDINAL_POSITION</B> int => index of column in table (starting at 1)
+ * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely does not allow
+ * NULL values; "YES" means the column might allow NULL values. An empty string
+ * means nobody knows.
+ * <LI><B>SCOPE_CATLOG</B> String => catalog of table that is the scope of a
+ * reference attribute (<code>null</code> if DATA_TYPE isn't REF)
+ * <LI><B>SCOPE_SCHEMA</B> String => schema of table that is the scope of a
+ * reference attribute (<code>null</code> if the DATA_TYPE isn't REF)
+ * <LI><B>SCOPE_TABLE</B> String => table name that this the scope of a
+ * reference attribure (<code>null</code> if the DATA_TYPE isn't REF)
+ * <LI><B>SOURCE_DATA_TYPE</B> short => source type of a distinct type or
+ * user-generated Ref type, SQL type from java.sql.Types (<code>null</code> if
+ * DATA_TYPE isn't DISTINCT or user-generated REF)
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param tableNamePattern a table name pattern; must match the
- * table name as it is stored in the database
- * @param columnNamePattern a column name pattern; must match the column
- * name as it is stored in the database
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param tableNamePattern a table name pattern; must match the table name as it
+ * is stored in the database
+ * @param columnNamePattern a column name pattern; must match the column name as
+ * it is stored in the database
* @return <code>ResultSet</code> - each row is a column description
* @throws java.sql.SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
- public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern,
- String columnNamePattern) throws SQLException {
+ public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)
+ throws SQLException {
return databaseMetaData.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern);
}
/**
* Retrieves a description of the access rights for a table's columns.
* <p/>
- * <P>Only privileges matching the column name criteria are
- * returned. They are ordered by COLUMN_NAME and PRIVILEGE.
+ * <P>
+ * Only privileges matching the column name criteria are returned. They are
+ * ordered by COLUMN_NAME and PRIVILEGE.
* <p/>
- * <P>Each privilige description has the following columns:
+ * <P>
+ * Each privilige description has the following columns:
* <OL>
* <LI><B>TABLE_CAT</B> String => table catalog (may be <code>null</code>)
* <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
@@ -1697,130 +1680,126 @@
* <LI><B>COLUMN_NAME</B> String => column name
* <LI><B>GRANTOR</B> => grantor of access (may be <code>null</code>)
* <LI><B>GRANTEE</B> String => grantee of access
- * <LI><B>PRIVILEGE</B> String => name of access (SELECT,
- * INSERT, UPDATE, REFRENCES, ...)
- * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted
- * to grant to others; "NO" if not; <code>null</code> if unknown
+ * <LI><B>PRIVILEGE</B> String => name of access (SELECT, INSERT, UPDATE,
+ * REFRENCES, ...)
+ * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted to grant to
+ * others; "NO" if not; <code>null</code> if unknown
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name as it is
- * stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is
- * stored in the database
- * @param columnNamePattern a column name pattern; must match the column
- * name as it is stored in the database
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * the database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in the
+ * database
+ * @param columnNamePattern a column name pattern; must match the column name as
+ * it is stored in the database
* @return <code>ResultSet</code> - each row is a column privilege description
* @throws java.sql.SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
- public ResultSet getColumnPrivileges(String catalog, String schema, String table,
- String columnNamePattern) throws SQLException {
+ public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)
+ throws SQLException {
return databaseMetaData.getColumnPrivileges(catalog, schema, table, columnNamePattern);
}
/**
- * Retrieves a description of the access rights for each table available
- * in a catalog. Note that a table privilege applies to one or
- * more columns in the table. It would be wrong to assume that
- * this privilege applies to all columns (this may be true for
- * some systems but is not true for all.)
+ * Retrieves a description of the access rights for each table available in a
+ * catalog. Note that a table privilege applies to one or more columns in the
+ * table. It would be wrong to assume that this privilege applies to all columns
+ * (this may be true for some systems but is not true for all.)
* <p/>
- * <P>Only privileges matching the schema and table name
- * criteria are returned. They are ordered by TABLE_SCHEM,
- * TABLE_NAME, and PRIVILEGE.
+ * <P>
+ * Only privileges matching the schema and table name criteria are returned.
+ * They are ordered by TABLE_SCHEM, TABLE_NAME, and PRIVILEGE.
* <p/>
- * <P>Each privilige description has the following columns:
+ * <P>
+ * Each privilige description has the following columns:
* <OL>
* <LI><B>TABLE_CAT</B> String => table catalog (may be <code>null</code>)
* <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
* <LI><B>TABLE_NAME</B> String => table name
* <LI><B>GRANTOR</B> => grantor of access (may be <code>null</code>)
* <LI><B>GRANTEE</B> String => grantee of access
- * <LI><B>PRIVILEGE</B> String => name of access (SELECT,
- * INSERT, UPDATE, REFRENCES, ...)
- * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted
- * to grant to others; "NO" if not; <code>null</code> if unknown
+ * <LI><B>PRIVILEGE</B> String => name of access (SELECT, INSERT, UPDATE,
+ * REFRENCES, ...)
+ * <LI><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted to grant to
+ * others; "NO" if not; <code>null</code> if unknown
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param tableNamePattern a table name pattern; must match the
- * table name as it is stored in the database
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param tableNamePattern a table name pattern; must match the table name as it
+ * is stored in the database
* @return <code>ResultSet</code> - each row is a table privilege description
* @throws java.sql.SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
- public ResultSet getTablePrivileges(String catalog, String schemaPattern,
- String tableNamePattern) throws SQLException {
+ public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)
+ throws SQLException {
return databaseMetaData.getTablePrivileges(catalog, schemaPattern, tableNamePattern);
}
/**
- * Retrieves a description of a table's optimal set of columns that
- * uniquely identifies a row. They are ordered by SCOPE.
+ * Retrieves a description of a table's optimal set of columns that uniquely
+ * identifies a row. They are ordered by SCOPE.
* <p/>
- * <P>Each column description has the following columns:
+ * <P>
+ * Each column description has the following columns:
* <OL>
* <LI><B>SCOPE</B> short => actual scope of result
* <UL>
- * <LI> bestRowTemporary - very temporary, while using row
- * <LI> bestRowTransaction - valid for remainder of current transaction
- * <LI> bestRowSession - valid for remainder of current session
+ * <LI>bestRowTemporary - very temporary, while using row
+ * <LI>bestRowTransaction - valid for remainder of current transaction
+ * <LI>bestRowSession - valid for remainder of current session
* </UL>
* <LI><B>COLUMN_NAME</B> String => column name
* <LI><B>DATA_TYPE</B> int => SQL data type from java.sql.Types
- * <LI><B>TYPE_NAME</B> String => Data source dependent type name,
- * for a UDT the type name is fully qualified
+ * <LI><B>TYPE_NAME</B> String => Data source dependent type name, for a UDT the
+ * type name is fully qualified
* <LI><B>COLUMN_SIZE</B> int => precision
* <LI><B>BUFFER_LENGTH</B> int => not used
- * <LI><B>DECIMAL_DIGITS</B> short => scale
- * <LI><B>PSEUDO_COLUMN</B> short => is this a pseudo column
- * like an Oracle ROWID
+ * <LI><B>DECIMAL_DIGITS</B> short => scale
+ * <LI><B>PSEUDO_COLUMN</B> short => is this a pseudo column like an Oracle
+ * ROWID
* <UL>
- * <LI> bestRowUnknown - may or may not be pseudo column
- * <LI> bestRowNotPseudo - is NOT a pseudo column
- * <LI> bestRowPseudo - is a pseudo column
+ * <LI>bestRowUnknown - may or may not be pseudo column
+ * <LI>bestRowNotPseudo - is NOT a pseudo column
+ * <LI>bestRowPseudo - is a pseudo column
* </UL>
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is stored
- * in the database
- * @param scope the scope of interest; use same values as SCOPE
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * the database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in the
+ * database
+ * @param scope the scope of interest; use same values as SCOPE
* @param nullable include columns that are nullable.
* @return <code>ResultSet</code> - each row is a column description
* @throws java.sql.SQLException if a database access error occurs
*/
- public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope,
- boolean nullable) throws SQLException {
+ public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)
+ throws SQLException {
return databaseMetaData.getBestRowIdentifier(catalog, schema, table, scope, nullable);
}
/**
- * Retrieves a description of a table's columns that are automatically
- * updated when any value in a row is updated. They are
- * unordered.
+ * Retrieves a description of a table's columns that are automatically updated
+ * when any value in a row is updated. They are unordered.
* <p/>
- * <P>Each column description has the following columns:
+ * <P>
+ * Each column description has the following columns:
* <OL>
* <LI><B>SCOPE</B> short => is not used
* <LI><B>COLUMN_NAME</B> String => column name
@@ -1828,28 +1807,26 @@
* <LI><B>TYPE_NAME</B> String => Data source-dependent type name
* <LI><B>COLUMN_SIZE</B> int => precision
* <LI><B>BUFFER_LENGTH</B> int => length of column value in bytes
- * <LI><B>DECIMAL_DIGITS</B> short => scale
- * <LI><B>PSEUDO_COLUMN</B> short => whether this is pseudo column
- * like an Oracle ROWID
+ * <LI><B>DECIMAL_DIGITS</B> short => scale
+ * <LI><B>PSEUDO_COLUMN</B> short => whether this is pseudo column like an
+ * Oracle ROWID
* <UL>
- * <LI> versionColumnUnknown - may or may not be pseudo column
- * <LI> versionColumnNotPseudo - is NOT a pseudo column
- * <LI> versionColumnPseudo - is a pseudo column
+ * <LI>versionColumnUnknown - may or may not be pseudo column
+ * <LI>versionColumnNotPseudo - is NOT a pseudo column
+ * <LI>versionColumnPseudo - is a pseudo column
* </UL>
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is stored
- * in the database
- * @return a <code>ResultSet</code> object in which each row is a
- * column description
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * the database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in the
+ * database
+ * @return a <code>ResultSet</code> object in which each row is a column
+ * description
* @throws java.sql.SQLException if a database access error occurs
*/
public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException {
@@ -1857,10 +1834,11 @@
}
/**
- * Retrieves a description of the given table's primary key columns. They
- * are ordered by COLUMN_NAME.
+ * Retrieves a description of the given table's primary key columns. They are
+ * ordered by COLUMN_NAME.
* <p/>
- * <P>Each primary key column description has the following columns:
+ * <P>
+ * Each primary key column description has the following columns:
* <OL>
* <LI><B>TABLE_CAT</B> String => table catalog (may be <code>null</code>)
* <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
@@ -1870,16 +1848,14 @@
* <LI><B>PK_NAME</B> String => primary key name (may be <code>null</code>)
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is stored
- * in the database
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * the database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in the
+ * database
* @return <code>ResultSet</code> - each row is a primary key column description
* @throws java.sql.SQLException if a database access error occurs
*/
@@ -1888,74 +1864,71 @@
}
/**
- * Retrieves a description of the primary key columns that are
- * referenced by a table's foreign key columns (the primary keys
- * imported by a table). They are ordered by PKTABLE_CAT,
- * PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ.
+ * Retrieves a description of the primary key columns that are referenced by a
+ * table's foreign key columns (the primary keys imported by a table). They are
+ * ordered by PKTABLE_CAT, PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ.
* <p/>
- * <P>Each primary key column description has the following columns:
+ * <P>
+ * Each primary key column description has the following columns:
* <OL>
- * <LI><B>PKTABLE_CAT</B> String => primary key table catalog
- * being imported (may be <code>null</code>)
- * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema
- * being imported (may be <code>null</code>)
- * <LI><B>PKTABLE_NAME</B> String => primary key table name
- * being imported
- * <LI><B>PKCOLUMN_NAME</B> String => primary key column name
- * being imported
- * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be <code>null</code>)
- * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be <code>null</code>)
+ * <LI><B>PKTABLE_CAT</B> String => primary key table catalog being imported
+ * (may be <code>null</code>)
+ * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema being imported
+ * (may be <code>null</code>)
+ * <LI><B>PKTABLE_NAME</B> String => primary key table name being imported
+ * <LI><B>PKCOLUMN_NAME</B> String => primary key column name being imported
+ * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be
+ * <code>null</code>)
+ * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be
+ * <code>null</code>)
* <LI><B>FKTABLE_NAME</B> String => foreign key table name
* <LI><B>FKCOLUMN_NAME</B> String => foreign key column name
* <LI><B>KEY_SEQ</B> short => sequence number within a foreign key
- * <LI><B>UPDATE_RULE</B> short => What happens to a
- * foreign key when the primary key is updated:
+ * <LI><B>UPDATE_RULE</B> short => What happens to a foreign key when the
+ * primary key is updated:
* <UL>
- * <LI> importedNoAction - do not allow update of primary
- * key if it has been imported
- * <LI> importedKeyCascade - change imported key to agree
- * with primary key update
- * <LI> importedKeySetNull - change imported key to <code>NULL</code>
- * if its primary key has been updated
- * <LI> importedKeySetDefault - change imported key to default values
- * if its primary key has been updated
- * <LI> importedKeyRestrict - same as importedKeyNoAction
- * (for ODBC 2.x compatibility)
+ * <LI>importedNoAction - do not allow update of primary key if it has been
+ * imported
+ * <LI>importedKeyCascade - change imported key to agree with primary key update
+ * <LI>importedKeySetNull - change imported key to <code>NULL</code> if its
+ * primary key has been updated
+ * <LI>importedKeySetDefault - change imported key to default values if its
+ * primary key has been updated
+ * <LI>importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
+ * compatibility)
* </UL>
- * <LI><B>DELETE_RULE</B> short => What happens to
- * the foreign key when primary is deleted.
+ * <LI><B>DELETE_RULE</B> short => What happens to the foreign key when primary
+ * is deleted.
* <UL>
- * <LI> importedKeyNoAction - do not allow delete of primary
- * key if it has been imported
- * <LI> importedKeyCascade - delete rows that import a deleted key
- * <LI> importedKeySetNull - change imported key to NULL if
- * its primary key has been deleted
- * <LI> importedKeyRestrict - same as importedKeyNoAction
- * (for ODBC 2.x compatibility)
- * <LI> importedKeySetDefault - change imported key to default if
- * its primary key has been deleted
+ * <LI>importedKeyNoAction - do not allow delete of primary key if it has been
+ * imported
+ * <LI>importedKeyCascade - delete rows that import a deleted key
+ * <LI>importedKeySetNull - change imported key to NULL if its primary key has
+ * been deleted
+ * <LI>importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
+ * compatibility)
+ * <LI>importedKeySetDefault - change imported key to default if its primary key
+ * has been deleted
* </UL>
* <LI><B>FK_NAME</B> String => foreign key name (may be <code>null</code>)
* <LI><B>PK_NAME</B> String => primary key name (may be <code>null</code>)
* <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key
* constraints be deferred until commit
* <UL>
- * <LI> importedKeyInitiallyDeferred - see SQL92 for definition
- * <LI> importedKeyInitiallyImmediate - see SQL92 for definition
- * <LI> importedKeyNotDeferrable - see SQL92 for definition
+ * <LI>importedKeyInitiallyDeferred - see SQL92 for definition
+ * <LI>importedKeyInitiallyImmediate - see SQL92 for definition
+ * <LI>importedKeyNotDeferrable - see SQL92 for definition
* </UL>
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is stored
- * in the database
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * the database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in the
+ * database
* @return <code>ResultSet</code> - each row is a primary key column description
* @throws java.sql.SQLException if a database access error occurs
* @see #getExportedKeys
@@ -1965,76 +1938,73 @@
}
/**
- * Retrieves a description of the foreign key columns that reference the
- * given table's primary key columns (the foreign keys exported by a
- * table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
- * FKTABLE_NAME, and KEY_SEQ.
+ * Retrieves a description of the foreign key columns that reference the given
+ * table's primary key columns (the foreign keys exported by a table). They are
+ * ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and KEY_SEQ.
* <p/>
- * <P>Each foreign key column description has the following columns:
+ * <P>
+ * Each foreign key column description has the following columns:
* <OL>
- * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be <code>null</code>)
- * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be <code>null</code>)
+ * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be
+ * <code>null</code>)
+ * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be
+ * <code>null</code>)
* <LI><B>PKTABLE_NAME</B> String => primary key table name
* <LI><B>PKCOLUMN_NAME</B> String => primary key column name
- * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be <code>null</code>)
- * being exported (may be <code>null</code>)
- * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be <code>null</code>)
- * being exported (may be <code>null</code>)
- * <LI><B>FKTABLE_NAME</B> String => foreign key table name
- * being exported
- * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name
- * being exported
+ * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be
+ * <code>null</code>) being exported (may be <code>null</code>)
+ * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be
+ * <code>null</code>) being exported (may be <code>null</code>)
+ * <LI><B>FKTABLE_NAME</B> String => foreign key table name being exported
+ * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name being exported
* <LI><B>KEY_SEQ</B> short => sequence number within foreign key
- * <LI><B>UPDATE_RULE</B> short => What happens to
- * foreign key when primary is updated:
+ * <LI><B>UPDATE_RULE</B> short => What happens to foreign key when primary is
+ * updated:
* <UL>
- * <LI> importedNoAction - do not allow update of primary
- * key if it has been imported
- * <LI> importedKeyCascade - change imported key to agree
- * with primary key update
- * <LI> importedKeySetNull - change imported key to <code>NULL</code> if
- * its primary key has been updated
- * <LI> importedKeySetDefault - change imported key to default values
- * if its primary key has been updated
- * <LI> importedKeyRestrict - same as importedKeyNoAction
- * (for ODBC 2.x compatibility)
+ * <LI>importedNoAction - do not allow update of primary key if it has been
+ * imported
+ * <LI>importedKeyCascade - change imported key to agree with primary key update
+ * <LI>importedKeySetNull - change imported key to <code>NULL</code> if its
+ * primary key has been updated
+ * <LI>importedKeySetDefault - change imported key to default values if its
+ * primary key has been updated
+ * <LI>importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
+ * compatibility)
* </UL>
- * <LI><B>DELETE_RULE</B> short => What happens to
- * the foreign key when primary is deleted.
+ * <LI><B>DELETE_RULE</B> short => What happens to the foreign key when primary
+ * is deleted.
* <UL>
- * <LI> importedKeyNoAction - do not allow delete of primary
- * key if it has been imported
- * <LI> importedKeyCascade - delete rows that import a deleted key
- * <LI> importedKeySetNull - change imported key to <code>NULL</code> if
- * its primary key has been deleted
- * <LI> importedKeyRestrict - same as importedKeyNoAction
- * (for ODBC 2.x compatibility)
- * <LI> importedKeySetDefault - change imported key to default if
- * its primary key has been deleted
+ * <LI>importedKeyNoAction - do not allow delete of primary key if it has been
+ * imported
+ * <LI>importedKeyCascade - delete rows that import a deleted key
+ * <LI>importedKeySetNull - change imported key to <code>NULL</code> if its
+ * primary key has been deleted
+ * <LI>importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
+ * compatibility)
+ * <LI>importedKeySetDefault - change imported key to default if its primary key
+ * has been deleted
* </UL>
* <LI><B>FK_NAME</B> String => foreign key name (may be <code>null</code>)
* <LI><B>PK_NAME</B> String => primary key name (may be <code>null</code>)
* <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key
* constraints be deferred until commit
* <UL>
- * <LI> importedKeyInitiallyDeferred - see SQL92 for definition
- * <LI> importedKeyInitiallyImmediate - see SQL92 for definition
- * <LI> importedKeyNotDeferrable - see SQL92 for definition
+ * <LI>importedKeyInitiallyDeferred - see SQL92 for definition
+ * <LI>importedKeyInitiallyImmediate - see SQL92 for definition
+ * <LI>importedKeyNotDeferrable - see SQL92 for definition
* </UL>
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in this database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is stored
- * in this database
- * @return a <code>ResultSet</code> object in which each row is a
- * foreign key column description
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * this database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * the database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in this
+ * database
+ * @return a <code>ResultSet</code> object in which each row is a foreign key
+ * column description
* @throws java.sql.SQLException if a database access error occurs
* @see #getImportedKeys
*/
@@ -2044,129 +2014,128 @@
/**
* Retrieves a description of the foreign key columns in the given foreign key
- * table that reference the primary key columns of the given primary key
- * table (describe how one table imports another's key). This
- * should normally return a single foreign key/primary key pair because
- * most tables import a foreign key from a table only once. They
- * are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and
- * KEY_SEQ.
+ * table that reference the primary key columns of the given primary key table
+ * (describe how one table imports another's key). This should normally return a
+ * single foreign key/primary key pair because most tables import a foreign key
+ * from a table only once. They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
+ * FKTABLE_NAME, and KEY_SEQ.
* <p/>
- * <P>Each foreign key column description has the following columns:
+ * <P>
+ * Each foreign key column description has the following columns:
* <OL>
- * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be <code>null</code>)
- * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be <code>null</code>)
+ * <LI><B>PKTABLE_CAT</B> String => primary key table catalog (may be
+ * <code>null</code>)
+ * <LI><B>PKTABLE_SCHEM</B> String => primary key table schema (may be
+ * <code>null</code>)
* <LI><B>PKTABLE_NAME</B> String => primary key table name
* <LI><B>PKCOLUMN_NAME</B> String => primary key column name
- * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be <code>null</code>)
- * being exported (may be <code>null</code>)
- * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be <code>null</code>)
- * being exported (may be <code>null</code>)
- * <LI><B>FKTABLE_NAME</B> String => foreign key table name
- * being exported
- * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name
- * being exported
+ * <LI><B>FKTABLE_CAT</B> String => foreign key table catalog (may be
+ * <code>null</code>) being exported (may be <code>null</code>)
+ * <LI><B>FKTABLE_SCHEM</B> String => foreign key table schema (may be
+ * <code>null</code>) being exported (may be <code>null</code>)
+ * <LI><B>FKTABLE_NAME</B> String => foreign key table name being exported
+ * <LI><B>FKCOLUMN_NAME</B> String => foreign key column name being exported
* <LI><B>KEY_SEQ</B> short => sequence number within foreign key
- * <LI><B>UPDATE_RULE</B> short => What happens to
- * foreign key when primary is updated:
+ * <LI><B>UPDATE_RULE</B> short => What happens to foreign key when primary is
+ * updated:
* <UL>
- * <LI> importedNoAction - do not allow update of primary
- * key if it has been imported
- * <LI> importedKeyCascade - change imported key to agree
- * with primary key update
- * <LI> importedKeySetNull - change imported key to <code>NULL</code> if
- * its primary key has been updated
- * <LI> importedKeySetDefault - change imported key to default values
- * if its primary key has been updated
- * <LI> importedKeyRestrict - same as importedKeyNoAction
- * (for ODBC 2.x compatibility)
+ * <LI>importedNoAction - do not allow update of primary key if it has been
+ * imported
+ * <LI>importedKeyCascade - change imported key to agree with primary key update
+ * <LI>importedKeySetNull - change imported key to <code>NULL</code> if its
+ * primary key has been updated
+ * <LI>importedKeySetDefault - change imported key to default values if its
+ * primary key has been updated
+ * <LI>importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
+ * compatibility)
* </UL>
- * <LI><B>DELETE_RULE</B> short => What happens to
- * the foreign key when primary is deleted.
+ * <LI><B>DELETE_RULE</B> short => What happens to the foreign key when primary
+ * is deleted.
* <UL>
- * <LI> importedKeyNoAction - do not allow delete of primary
- * key if it has been imported
- * <LI> importedKeyCascade - delete rows that import a deleted key
- * <LI> importedKeySetNull - change imported key to <code>NULL</code> if
- * its primary key has been deleted
- * <LI> importedKeyRestrict - same as importedKeyNoAction
- * (for ODBC 2.x compatibility)
- * <LI> importedKeySetDefault - change imported key to default if
- * its primary key has been deleted
+ * <LI>importedKeyNoAction - do not allow delete of primary key if it has been
+ * imported
+ * <LI>importedKeyCascade - delete rows that import a deleted key
+ * <LI>importedKeySetNull - change imported key to <code>NULL</code> if its
+ * primary key has been deleted
+ * <LI>importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x
+ * compatibility)
+ * <LI>importedKeySetDefault - change imported key to default if its primary key
+ * has been deleted
* </UL>
* <LI><B>FK_NAME</B> String => foreign key name (may be <code>null</code>)
* <LI><B>PK_NAME</B> String => primary key name (may be <code>null</code>)
* <LI><B>DEFERRABILITY</B> short => can the evaluation of foreign key
* constraints be deferred until commit
* <UL>
- * <LI> importedKeyInitiallyDeferred - see SQL92 for definition
- * <LI> importedKeyInitiallyImmediate - see SQL92 for definition
- * <LI> importedKeyNotDeferrable - see SQL92 for definition
+ * <LI>importedKeyInitiallyDeferred - see SQL92 for definition
+ * <LI>importedKeyInitiallyImmediate - see SQL92 for definition
+ * <LI>importedKeyNotDeferrable - see SQL92 for definition
* </UL>
* </OL>
*
- * @param primaryCatalog a catalog name; must match the catalog name
- * as it is stored in the database; "" retrieves those without a
- * catalog; <code>null</code> means drop catalog name from the selection criteria
- * @param primarySchema a schema name; must match the schema name as
- * it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means drop schema name from the selection criteria
- * @param primaryTable the name of the table that exports the key; must match
- * the table name as it is stored in the database
- * @param foreignCatalog a catalog name; must match the catalog name as
- * it is stored in the database; "" retrieves those without a
- * catalog; <code>null</code> means drop catalog name from the selection criteria
- * @param foreignSchema a schema name; must match the schema name as it
- * is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means drop schema name from the selection criteria
- * @param foreignTable the name of the table that imports the key; must match
- * the table name as it is stored in the database
+ * @param primaryCatalog a catalog name; must match the catalog name as it is
+ * stored in the database; "" retrieves those without a catalog;
+ * <code>null</code> means drop catalog name from the selection criteria
+ * @param primarySchema a schema name; must match the schema name as it is
+ * stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means drop schema name from the selection criteria
+ * @param primaryTable the name of the table that exports the key; must match
+ * the table name as it is stored in the database
+ * @param foreignCatalog a catalog name; must match the catalog name as it is
+ * stored in the database; "" retrieves those without a catalog;
+ * <code>null</code> means drop catalog name from the selection criteria
+ * @param foreignSchema a schema name; must match the schema name as it is
+ * stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means drop schema name from the selection criteria
+ * @param foreignTable the name of the table that imports the key; must match
+ * the table name as it is stored in the database
* @return <code>ResultSet</code> - each row is a foreign key column description
* @throws java.sql.SQLException if a database access error occurs
* @see #getImportedKeys
*/
public ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable,
- String foreignCatalog, String foreignSchema, String foreignTable)
- throws SQLException {
- return databaseMetaData.getCrossReference(primaryCatalog, primarySchema, primaryTable,
- foreignCatalog, foreignSchema, foreignTable);
+ String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException {
+ return databaseMetaData.getCrossReference(primaryCatalog, primarySchema, primaryTable, foreignCatalog,
+ foreignSchema, foreignTable);
}
/**
- * Retrieves a description of all the standard SQL types supported by
- * this database. They are ordered by DATA_TYPE and then by how
- * closely the data type maps to the corresponding JDBC SQL type.
+ * Retrieves a description of all the standard SQL types supported by this
+ * database. They are ordered by DATA_TYPE and then by how closely the data type
+ * maps to the corresponding JDBC SQL type.
* <p/>
- * <P>Each type description has the following columns:
+ * <P>
+ * Each type description has the following columns:
* <OL>
* <LI><B>TYPE_NAME</B> String => Type name
* <LI><B>DATA_TYPE</B> int => SQL data type from java.sql.Types
* <LI><B>PRECISION</B> int => maximum precision
- * <LI><B>LITERAL_PREFIX</B> String => prefix used to quote a literal
- * (may be <code>null</code>)
- * <LI><B>LITERAL_SUFFIX</B> String => suffix used to quote a literal
- * (may be <code>null</code>)
- * <LI><B>CREATE_PARAMS</B> String => parameters used in creating
- * the type (may be <code>null</code>)
+ * <LI><B>LITERAL_PREFIX</B> String => prefix used to quote a literal (may be
+ * <code>null</code>)
+ * <LI><B>LITERAL_SUFFIX</B> String => suffix used to quote a literal (may be
+ * <code>null</code>)
+ * <LI><B>CREATE_PARAMS</B> String => parameters used in creating the type (may
+ * be <code>null</code>)
* <LI><B>NULLABLE</B> short => can you use NULL for this type.
* <UL>
- * <LI> typeNoNulls - does not allow NULL values
- * <LI> typeNullable - allows NULL values
- * <LI> typeNullableUnknown - nullability unknown
+ * <LI>typeNoNulls - does not allow NULL values
+ * <LI>typeNullable - allows NULL values
+ * <LI>typeNullableUnknown - nullability unknown
* </UL>
* <LI><B>CASE_SENSITIVE</B> boolean=> is it case sensitive.
* <LI><B>SEARCHABLE</B> short => can you use "WHERE" based on this type:
* <UL>
- * <LI> typePredNone - No support
- * <LI> typePredChar - Only supported with WHERE .. LIKE
- * <LI> typePredBasic - Supported except for WHERE .. LIKE
- * <LI> typeSearchable - Supported for all WHERE ..
+ * <LI>typePredNone - No support
+ * <LI>typePredChar - Only supported with WHERE .. LIKE
+ * <LI>typePredBasic - Supported except for WHERE .. LIKE
+ * <LI>typeSearchable - Supported for all WHERE ..
* </UL>
* <LI><B>UNSIGNED_ATTRIBUTE</B> boolean => is it unsigned.
* <LI><B>FIXED_PREC_SCALE</B> boolean => can it be a money value.
- * <LI><B>AUTO_INCREMENT</B> boolean => can it be used for an
- * auto-increment value.
- * <LI><B>LOCAL_TYPE_NAME</B> String => localized version of type name
- * (may be <code>null</code>)
+ * <LI><B>AUTO_INCREMENT</B> boolean => can it be used for an auto-increment
+ * value.
+ * <LI><B>LOCAL_TYPE_NAME</B> String => localized version of type name (may be
+ * <code>null</code>)
* <LI><B>MINIMUM_SCALE</B> short => minimum scale supported
* <LI><B>MAXIMUM_SCALE</B> short => maximum scale supported
* <LI><B>SQL_DATA_TYPE</B> int => unused
@@ -2174,8 +2143,8 @@
* <LI><B>NUM_PREC_RADIX</B> int => usually 2 or 10
* </OL>
*
- * @return a <code>ResultSet</code> object in which each row is an SQL
- * type description
+ * @return a <code>ResultSet</code> object in which each row is an SQL type
+ * description
* @throws java.sql.SQLException if a database access error occurs
*/
public ResultSet getTypeInfo() throws SQLException {
@@ -2186,62 +2155,60 @@
* Retrieves a description of the given table's indices and statistics. They are
* ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION.
* <p/>
- * <P>Each index column description has the following columns:
+ * <P>
+ * Each index column description has the following columns:
* <OL>
* <LI><B>TABLE_CAT</B> String => table catalog (may be <code>null</code>)
* <LI><B>TABLE_SCHEM</B> String => table schema (may be <code>null</code>)
* <LI><B>TABLE_NAME</B> String => table name
- * <LI><B>NON_UNIQUE</B> boolean => Can index values be non-unique.
- * false when TYPE is tableIndexStatistic
- * <LI><B>INDEX_QUALIFIER</B> String => index catalog (may be <code>null</code>);
- * <code>null</code> when TYPE is tableIndexStatistic
+ * <LI><B>NON_UNIQUE</B> boolean => Can index values be non-unique. false when
+ * TYPE is tableIndexStatistic
+ * <LI><B>INDEX_QUALIFIER</B> String => index catalog (may be
+ * <code>null</code>); <code>null</code> when TYPE is tableIndexStatistic
* <LI><B>INDEX_NAME</B> String => index name; <code>null</code> when TYPE is
* tableIndexStatistic
* <LI><B>TYPE</B> short => index type:
* <UL>
- * <LI> tableIndexStatistic - this identifies table statistics that are
- * returned in conjuction with a table's index descriptions
- * <LI> tableIndexClustered - this is a clustered index
- * <LI> tableIndexHashed - this is a hashed index
- * <LI> tableIndexOther - this is some other style of index
+ * <LI>tableIndexStatistic - this identifies table statistics that are returned
+ * in conjuction with a table's index descriptions
+ * <LI>tableIndexClustered - this is a clustered index
+ * <LI>tableIndexHashed - this is a hashed index
+ * <LI>tableIndexOther - this is some other style of index
* </UL>
- * <LI><B>ORDINAL_POSITION</B> short => column sequence number
- * within index; zero when TYPE is tableIndexStatistic
+ * <LI><B>ORDINAL_POSITION</B> short => column sequence number within index;
+ * zero when TYPE is tableIndexStatistic
* <LI><B>COLUMN_NAME</B> String => column name; <code>null</code> when TYPE is
* tableIndexStatistic
- * <LI><B>ASC_OR_DESC</B> String => column sort sequence, "A" => ascending,
- * "D" => descending, may be <code>null</code> if sort sequence is not supported;
+ * <LI><B>ASC_OR_DESC</B> String => column sort sequence, "A" => ascending, "D"
+ * => descending, may be <code>null</code> if sort sequence is not supported;
* <code>null</code> when TYPE is tableIndexStatistic
- * <LI><B>CARDINALITY</B> int => When TYPE is tableIndexStatistic, then
- * this is the number of rows in the table; otherwise, it is the
- * number of unique values in the index.
- * <LI><B>PAGES</B> int => When TYPE is tableIndexStatisic then
- * this is the number of pages used for the table, otherwise it
- * is the number of pages used for the current index.
- * <LI><B>FILTER_CONDITION</B> String => Filter condition, if any.
- * (may be <code>null</code>)
+ * <LI><B>CARDINALITY</B> int => When TYPE is tableIndexStatistic, then this is
+ * the number of rows in the table; otherwise, it is the number of unique values
+ * in the index.
+ * <LI><B>PAGES</B> int => When TYPE is tableIndexStatisic then this is the
+ * number of pages used for the table, otherwise it is the number of pages used
+ * for the current index.
+ * <LI><B>FILTER_CONDITION</B> String => Filter condition, if any. (may be
+ * <code>null</code>)
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in this database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schema a schema name; must match the schema name
- * as it is stored in this database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param table a table name; must match the table name as it is stored
- * in this database
- * @param unique when true, return only indices for unique values;
- * when false, return indices regardless of whether unique or not
- * @param approximate when true, result is allowed to reflect approximate
- * or out of data values; when false, results are requested to be
- * accurate
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * this database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schema a schema name; must match the schema name as it is stored in
+ * this database; "" retrieves those without a schema; <code>null</code> means
+ * that the schema name should not be used to narrow the search
+ * @param table a table name; must match the table name as it is stored in this
+ * database
+ * @param unique when true, return only indices for unique values; when false,
+ * return indices regardless of whether unique or not
+ * @param approximate when true, result is allowed to reflect approximate or out
+ * of data values; when false, results are requested to be accurate
* @return <code>ResultSet</code> - each row is an index column description
* @throws java.sql.SQLException if a database access error occurs
*/
- public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique,
- boolean approximate) throws SQLException {
+ public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)
+ throws SQLException {
return databaseMetaData.getIndexInfo(catalog, schema, table, unique, approximate);
}
@@ -2259,10 +2226,10 @@
}
/**
- * Retrieves whether this database supports the given concurrency type
- * in combination with the given result set type.
+ * Retrieves whether this database supports the given concurrency type in
+ * combination with the given result set type.
*
- * @param type defined in <code>java.sql.ResultSet</code>
+ * @param type defined in <code>java.sql.ResultSet</code>
* @param concurrency type defined in <code>java.sql.ResultSet</code>
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
@@ -2274,15 +2241,15 @@
}
/**
- * Retrieves whether for the given type of <code>ResultSet</code> object,
- * the result set's own updates are visible.
+ * Retrieves whether for the given type of <code>ResultSet</code> object, the
+ * result set's own updates are visible.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if updates are visible for the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if updates are visible for the given result set
+ * type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2294,11 +2261,11 @@
* Retrieves whether a result set's own deletes are visible.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if deletes are visible for the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if deletes are visible for the given result set
+ * type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2310,11 +2277,11 @@
* Retrieves whether a result set's own inserts are visible.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if inserts are visible for the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if inserts are visible for the given result set
+ * type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2326,12 +2293,11 @@
* Retrieves whether updates made by others are visible.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if updates made by others
- * are visible for the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if updates made by others are visible for the given
+ * result set type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2343,12 +2309,11 @@
* Retrieves whether deletes made by others are visible.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if deletes made by others
- * are visible for the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if deletes made by others are visible for the given
+ * result set type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2360,12 +2325,11 @@
* Retrieves whether inserts made by others are visible.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if inserts made by others
- * are visible for the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if inserts made by others are visible for the given
+ * result set type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2374,15 +2338,15 @@
}
/**
- * Retrieves whether or not a visible row update can be detected by
- * calling the method <code>ResultSet.rowUpdated</code>.
+ * Retrieves whether or not a visible row update can be detected by calling the
+ * method <code>ResultSet.rowUpdated</code>.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
* @return <code>true</code> if changes are detected by the result set type;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2391,17 +2355,17 @@
}
/**
- * Retrieves whether or not a visible row delete can be detected by
- * calling the method <code>ResultSet.rowDeleted</code>. If the method
+ * Retrieves whether or not a visible row delete can be detected by calling the
+ * method <code>ResultSet.rowDeleted</code>. If the method
* <code>deletesAreDetected</code> returns <code>false</code>, it means that
* deleted rows are removed from the result set.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if deletes are detected by the given result set type;
- * <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if deletes are detected by the given result set
+ * type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2410,15 +2374,15 @@
}
/**
- * Retrieves whether or not a visible row insert can be detected
- * by calling the method <code>ResultSet.rowInserted</code>.
+ * Retrieves whether or not a visible row insert can be detected by calling the
+ * method <code>ResultSet.rowInserted</code>.
*
* @param type the <code>ResultSet</code> type; one of
- * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
- * @return <code>true</code> if changes are detected by the specified result
- * set type; <code>false</code> otherwise
+ * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * @return <code>true</code> if changes are detected by the specified result set
+ * type; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2430,7 +2394,7 @@
* Retrieves whether this database supports batch updates.
*
* @return <code>true</code> if this database supports batch upcates;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2439,53 +2403,54 @@
}
/**
- * Retrieves a description of the user-defined types (UDTs) defined
- * in a particular schema. Schema-specific UDTs may have type
- * <code>JAVA_OBJECT</code>, <code>STRUCT</code>,
- * or <code>DISTINCT</code>.
+ * Retrieves a description of the user-defined types (UDTs) defined in a
+ * particular schema. Schema-specific UDTs may have type
+ * <code>JAVA_OBJECT</code>, <code>STRUCT</code>, or <code>DISTINCT</code>.
* <p/>
- * <P>Only types matching the catalog, schema, type name and type
- * criteria are returned. They are ordered by DATA_TYPE, TYPE_SCHEM
- * and TYPE_NAME. The type name parameter may be a fully-qualified
- * name. In this case, the catalog and schemaPattern parameters are
- * ignored.
+ * <P>
+ * Only types matching the catalog, schema, type name and type criteria are
+ * returned. They are ordered by DATA_TYPE, TYPE_SCHEM and TYPE_NAME. The type
+ * name parameter may be a fully-qualified name. In this case, the catalog and
+ * schemaPattern parameters are ignored.
* <p/>
- * <P>Each type description has the following columns:
+ * <P>
+ * Each type description has the following columns:
* <OL>
* <LI><B>TYPE_CAT</B> String => the type's catalog (may be <code>null</code>)
* <LI><B>TYPE_SCHEM</B> String => type's schema (may be <code>null</code>)
* <LI><B>TYPE_NAME</B> String => type name
* <LI><B>CLASS_NAME</B> String => Java class name
- * <LI><B>DATA_TYPE</B> int => type value defined in java.sql.Types.
- * One of JAVA_OBJECT, STRUCT, or DISTINCT
+ * <LI><B>DATA_TYPE</B> int => type value defined in java.sql.Types. One of
+ * JAVA_OBJECT, STRUCT, or DISTINCT
* <LI><B>REMARKS</B> String => explanatory comment on the type
- * <LI><B>BASE_TYPE</B> short => type code of the source type of a
- * DISTINCT type or the type that implements the user-generated
- * reference type of the SELF_REFERENCING_COLUMN of a structured
- * type as defined in java.sql.Types (<code>null</code> if DATA_TYPE is not
- * DISTINCT or not STRUCT with REFERENCE_GENERATION = USER_DEFINED)
+ * <LI><B>BASE_TYPE</B> short => type code of the source type of a DISTINCT type
+ * or the type that implements the user-generated reference type of the
+ * SELF_REFERENCING_COLUMN of a structured type as defined in java.sql.Types
+ * (<code>null</code> if DATA_TYPE is not DISTINCT or not STRUCT with
+ * REFERENCE_GENERATION = USER_DEFINED)
* </OL>
* <p/>
- * <P><B>Note:</B> If the driver does not support UDTs, an empty
- * result set is returned.
+ * <P>
+ * <B>Note:</B> If the driver does not support UDTs, an empty result set is
+ * returned.
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema pattern name; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param typeNamePattern a type name pattern; must match the type name
- * as it is stored in the database; may be a fully qualified name
- * @param types a list of user-defined types (JAVA_OBJECT,
- * STRUCT, or DISTINCT) to include; <code>null</code> returns all types
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema pattern name; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param typeNamePattern a type name pattern; must match the type name as it is
+ * stored in the database; may be a fully qualified name
+ * @param types a list of user-defined types (JAVA_OBJECT, STRUCT, or DISTINCT)
+ * to include; <code>null</code> returns all types
* @return <code>ResultSet</code> object in which each row describes a UDT
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
- public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException {
+ public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types)
+ throws SQLException {
return databaseMetaData.getUDTs(catalog, schemaPattern, typeNamePattern, types);
}
@@ -2514,8 +2479,8 @@
/**
* Retrieves whether this database supports savepoints.
*
- * @return <code>true</code> if savepoints are supported;
- * <code>false</code> otherwise
+ * @return <code>true</code> if savepoints are supported; <code>false</code>
+ * otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2528,7 +2493,7 @@
* statements.
*
* @return <code>true</code> if named parameters are supported;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2537,13 +2502,12 @@
}
/**
- * Retrieves whether it is possible to have multiple <code>ResultSet</code> objects
- * returned from a <code>CallableStatement</code> object
- * simultaneously.
+ * Retrieves whether it is possible to have multiple <code>ResultSet</code>
+ * objects returned from a <code>CallableStatement</code> object simultaneously.
*
- * @return <code>true</code> if a <code>CallableStatement</code> object
- * can return multiple <code>ResultSet</code> objects
- * simultaneously; <code>false</code> otherwise
+ * @return <code>true</code> if a <code>CallableStatement</code> object can
+ * return multiple <code>ResultSet</code> objects simultaneously;
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a datanase access error occurs
* @since 1.4
*/
@@ -2552,11 +2516,11 @@
}
/**
- * Retrieves whether auto-generated keys can be retrieved after
- * a statement has been executed.
+ * Retrieves whether auto-generated keys can be retrieved after a statement has
+ * been executed.
*
- * @return <code>true</code> if auto-generated keys can be retrieved
- * after a statement has executed; <code>false</code> otherwise
+ * @return <code>true</code> if auto-generated keys can be retrieved after a
+ * statement has executed; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2565,42 +2529,40 @@
}
/**
- * Retrieves a description of the user-defined type (UDT) hierarchies defined in a
- * particular schema in this database. Only the immediate super type/
- * sub type relationship is modeled.
+ * Retrieves a description of the user-defined type (UDT) hierarchies defined in
+ * a particular schema in this database. Only the immediate super type/ sub type
+ * relationship is modeled.
* <p/>
- * Only supertype information for UDTs matching the catalog,
- * schema, and type name is returned. The type name parameter
- * may be a fully-qualified name. When the UDT name supplied is a
- * fully-qualified name, the catalog and schemaPattern parameters are
- * ignored.
+ * Only supertype information for UDTs matching the catalog, schema, and type
+ * name is returned. The type name parameter may be a fully-qualified name. When
+ * the UDT name supplied is a fully-qualified name, the catalog and
+ * schemaPattern parameters are ignored.
* <p/>
- * If a UDT does not have a direct super type, it is not listed here.
- * A row of the <code>ResultSet</code> object returned by this method
- * describes the designated UDT and a direct supertype. A row has the following
- * columns:
+ * If a UDT does not have a direct super type, it is not listed here. A row of
+ * the <code>ResultSet</code> object returned by this method describes the
+ * designated UDT and a direct supertype. A row has the following columns:
* <OL>
* <LI><B>TYPE_CAT</B> String => the UDT's catalog (may be <code>null</code>)
* <LI><B>TYPE_SCHEM</B> String => UDT's schema (may be <code>null</code>)
* <LI><B>TYPE_NAME</B> String => type name of the UDT
- * <LI><B>SUPERTYPE_CAT</B> String => the direct super type's catalog
- * (may be <code>null</code>)
- * <LI><B>SUPERTYPE_SCHEM</B> String => the direct super type's schema
- * (may be <code>null</code>)
+ * <LI><B>SUPERTYPE_CAT</B> String => the direct super type's catalog (may be
+ * <code>null</code>)
+ * <LI><B>SUPERTYPE_SCHEM</B> String => the direct super type's schema (may be
+ * <code>null</code>)
* <LI><B>SUPERTYPE_NAME</B> String => the direct super type's name
* </OL>
* <p/>
- * <P><B>Note:</B> If the driver does not support type hierarchies, an
- * empty result set is returned.
+ * <P>
+ * <B>Note:</B> If the driver does not support type hierarchies, an empty result
+ * set is returned.
*
- * @param catalog a catalog name; "" retrieves those without a catalog;
- * <code>null</code> means drop catalog name from the selection criteria
- * @param schemaPattern a schema name pattern; "" retrieves those
- * without a schema
- * @param typeNamePattern a UDT name pattern; may be a fully-qualified
- * name
+ * @param catalog a catalog name; "" retrieves those without a catalog;
+ * <code>null</code> means drop catalog name from the selection criteria
+ * @param schemaPattern a schema name pattern; "" retrieves those without a
+ * schema
+ * @param typeNamePattern a UDT name pattern; may be a fully-qualified name
* @return a <code>ResultSet</code> object in which a row gives information
- * about the designated UDT
+ * about the designated UDT
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2612,15 +2574,17 @@
* Retrieves a description of the table hierarchies defined in a particular
* schema in this database.
* <p/>
- * <P>Only supertable information for tables matching the catalog, schema
- * and table name are returned. The table name parameter may be a fully-
- * qualified name, in which case, the catalog and schemaPattern parameters
- * are ignored. If a table does not have a super table, it is not listed here.
- * Supertables have to be defined in the same catalog and schema as the
- * sub tables. Therefore, the type description does not need to include
- * this information for the supertable.
+ * <P>
+ * Only supertable information for tables matching the catalog, schema and table
+ * name are returned. The table name parameter may be a fully- qualified name,
+ * in which case, the catalog and schemaPattern parameters are ignored. If a
+ * table does not have a super table, it is not listed here. Supertables have to
+ * be defined in the same catalog and schema as the sub tables. Therefore, the
+ * type description does not need to include this information for the
+ * supertable.
* <p/>
- * <P>Each type description has the following columns:
+ * <P>
+ * Each type description has the following columns:
* <OL>
* <LI><B>TABLE_CAT</B> String => the type's catalog (may be <code>null</code>)
* <LI><B>TABLE_SCHEM</B> String => type's schema (may be <code>null</code>)
@@ -2628,16 +2592,17 @@
* <LI><B>SUPERTABLE_NAME</B> String => the direct super type's name
* </OL>
* <p/>
- * <P><B>Note:</B> If the driver does not support type hierarchies, an
- * empty result set is returned.
+ * <P>
+ * <B>Note:</B> If the driver does not support type hierarchies, an empty result
+ * set is returned.
*
- * @param catalog a catalog name; "" retrieves those without a catalog;
- * <code>null</code> means drop catalog name from the selection criteria
- * @param schemaPattern a schema name pattern; "" retrieves those
- * without a schema
- * @param tableNamePattern a table name pattern; may be a fully-qualified
- * name
- * @return a <code>ResultSet</code> object in which each row is a type description
+ * @param catalog a catalog name; "" retrieves those without a catalog;
+ * <code>null</code> means drop catalog name from the selection criteria
+ * @param schemaPattern a schema name pattern; "" retrieves those without a
+ * schema
+ * @param tableNamePattern a table name pattern; may be a fully-qualified name
+ * @return a <code>ResultSet</code> object in which each row is a type
+ * description
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2646,78 +2611,74 @@
}
/**
- * Retrieves a description of the given attribute of the given type
- * for a user-defined type (UDT) that is available in the given schema
- * and catalog.
+ * Retrieves a description of the given attribute of the given type for a
+ * user-defined type (UDT) that is available in the given schema and catalog.
* <p/>
- * Descriptions are returned only for attributes of UDTs matching the
- * catalog, schema, type, and attribute name criteria. They are ordered by
- * TYPE_SCHEM, TYPE_NAME and ORDINAL_POSITION. This description
- * does not contain inherited attributes.
+ * Descriptions are returned only for attributes of UDTs matching the catalog,
+ * schema, type, and attribute name criteria. They are ordered by TYPE_SCHEM,
+ * TYPE_NAME and ORDINAL_POSITION. This description does not contain inherited
+ * attributes.
* <p/>
- * The <code>ResultSet</code> object that is returned has the following
- * columns:
+ * The <code>ResultSet</code> object that is returned has the following columns:
* <OL>
* <LI><B>TYPE_CAT</B> String => type catalog (may be <code>null</code>)
* <LI><B>TYPE_SCHEM</B> String => type schema (may be <code>null</code>)
* <LI><B>TYPE_NAME</B> String => type name
* <LI><B>ATTR_NAME</B> String => attribute name
* <LI><B>DATA_TYPE</B> int => attribute type SQL type from java.sql.Types
- * <LI><B>ATTR_TYPE_NAME</B> String => Data source dependent type name.
- * For a UDT, the type name is fully qualified. For a REF, the type name is
- * fully qualified and represents the target type of the reference type.
- * <LI><B>ATTR_SIZE</B> int => column size. For char or date
- * types this is the maximum number of characters; for numeric or
- * decimal types this is precision.
+ * <LI><B>ATTR_TYPE_NAME</B> String => Data source dependent type name. For a
+ * UDT, the type name is fully qualified. For a REF, the type name is fully
+ * qualified and represents the target type of the reference type.
+ * <LI><B>ATTR_SIZE</B> int => column size. For char or date types this is the
+ * maximum number of characters; for numeric or decimal types this is precision.
* <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits
* <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2)
* <LI><B>NULLABLE</B> int => whether NULL is allowed
* <UL>
- * <LI> attributeNoNulls - might not allow NULL values
- * <LI> attributeNullable - definitely allows NULL values
- * <LI> attributeNullableUnknown - nullability unknown
+ * <LI>attributeNoNulls - might not allow NULL values
+ * <LI>attributeNullable - definitely allows NULL values
+ * <LI>attributeNullableUnknown - nullability unknown
* </UL>
- * <LI><B>REMARKS</B> String => comment describing column (may be <code>null</code>)
+ * <LI><B>REMARKS</B> String => comment describing column (may be
+ * <code>null</code>)
* <LI><B>ATTR_DEF</B> String => default value (may be <code>null</code>)
* <LI><B>SQL_DATA_TYPE</B> int => unused
* <LI><B>SQL_DATETIME_SUB</B> int => unused
- * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the
- * maximum number of bytes in the column
- * <LI><B>ORDINAL_POSITION</B> int => index of column in table
- * (starting at 1)
- * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely
- * does not allow NULL values; "YES" means the column might
- * allow NULL values. An empty string means unknown.
- * <LI><B>SCOPE_CATALOG</B> String => catalog of table that is the
- * scope of a reference attribute (<code>null</code> if DATA_TYPE isn't REF)
- * <LI><B>SCOPE_SCHEMA</B> String => schema of table that is the
- * scope of a reference attribute (<code>null</code> if DATA_TYPE isn't REF)
- * <LI><B>SCOPE_TABLE</B> String => table name that is the scope of a
- * reference attribute (<code>null</code> if the DATA_TYPE isn't REF)
- * <LI><B>SOURCE_DATA_TYPE</B> short => source type of a distinct type or user-generated
- * Ref type,SQL type from java.sql.Types (<code>null</code> if DATA_TYPE
- * isn't DISTINCT or user-generated REF)
+ * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the maximum number of
+ * bytes in the column
+ * <LI><B>ORDINAL_POSITION</B> int => index of column in table (starting at 1)
+ * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely does not allow
+ * NULL values; "YES" means the column might allow NULL values. An empty string
+ * means unknown.
+ * <LI><B>SCOPE_CATALOG</B> String => catalog of table that is the scope of a
+ * reference attribute (<code>null</code> if DATA_TYPE isn't REF)
+ * <LI><B>SCOPE_SCHEMA</B> String => schema of table that is the scope of a
+ * reference attribute (<code>null</code> if DATA_TYPE isn't REF)
+ * <LI><B>SCOPE_TABLE</B> String => table name that is the scope of a reference
+ * attribute (<code>null</code> if the DATA_TYPE isn't REF)
+ * <LI><B>SOURCE_DATA_TYPE</B> short => source type of a distinct type or
+ * user-generated Ref type,SQL type from java.sql.Types (<code>null</code> if
+ * DATA_TYPE isn't DISTINCT or user-generated REF)
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param typeNamePattern a type name pattern; must match the
- * type name as it is stored in the database
- * @param attributeNamePattern an attribute name pattern; must match the attribute
- * name as it is declared in the database
- * @return a <code>ResultSet</code> object in which each row is an
- * attribute description
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param typeNamePattern a type name pattern; must match the type name as it is
+ * stored in the database
+ * @param attributeNamePattern an attribute name pattern; must match the
+ * attribute name as it is declared in the database
+ * @return a <code>ResultSet</code> object in which each row is an attribute
+ * description
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern,
- String attributeNamePattern) throws SQLException {
+ String attributeNamePattern) throws SQLException {
return databaseMetaData.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern);
}
@@ -2725,9 +2686,9 @@
* Retrieves whether this database supports the given result set holdability.
*
* @param holdability one of the following constants:
- * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
- * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT<code>
- * @return <code>true</code> if so; <code>false</code> otherwise
+ * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
+ * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT<code>
+ * @return <code>true</code> if so; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Connection
* @since 1.4
@@ -2737,12 +2698,11 @@
}
/**
- * Retrieves the default holdability of this <code>ResultSet</code>
- * object.
+ * Retrieves the default holdability of this <code>ResultSet</code> object.
*
* @return the default holdability; either
- * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
- * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
+ * <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
+ * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2773,8 +2733,7 @@
}
/**
- * Retrieves the major JDBC version number for this
- * driver.
+ * Retrieves the major JDBC version number for this driver.
*
* @return JDBC version major number
* @throws java.sql.SQLException if a database access error occurs
@@ -2785,8 +2744,7 @@
}
/**
- * Retrieves the minor JDBC version number for this
- * driver.
+ * Retrieves the minor JDBC version number for this driver.
*
* @return JDBC version minor number
* @throws java.sql.SQLException if a database access error occurs
@@ -2797,12 +2755,11 @@
}
/**
- * Indicates whether the SQLSTATE returned by <code>SQLException.getSQLState</code>
- * is X/Open (now known as Open Group) SQL CLI or SQL99.
+ * Indicates whether the SQLSTATE returned by
+ * <code>SQLException.getSQLState</code> is X/Open (now known as Open Group) SQL
+ * CLI or SQL99.
*
- * @return the type of SQLSTATE; one of:
- * sqlStateXOpen or
- * sqlStateSQL99
+ * @return the type of SQLSTATE; one of: sqlStateXOpen or sqlStateSQL99
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2811,11 +2768,11 @@
}
/**
- * Indicates whether updates made to a LOB are made on a copy or directly
- * to the LOB.
+ * Indicates whether updates made to a LOB are made on a copy or directly to the
+ * LOB.
*
* @return <code>true</code> if updates are made to a copy of the LOB;
- * <code>false</code> if updates are made directly to the LOB
+ * <code>false</code> if updates are made directly to the LOB
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/PreparedStatementWrapper.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/PreparedStatementWrapper.java
index 5763f4c..40ad3d1 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/PreparedStatementWrapper.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/PreparedStatementWrapper.java
@@ -16,25 +16,38 @@
package com.sun.gjc.spi.base;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.util.ResultSetClosedEventListener;
+import static com.sun.gjc.common.DataSourceObjectBuilder.isJDBC41;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
-import java.sql.*;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.ParameterMetaData;
+import java.sql.PreparedStatement;
+import java.sql.Ref;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
import java.util.Calendar;
import java.util.logging.Level;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.util.ResultSetClosedEventListener;
+
/**
* Abstract class for wrapping PreparedStatement<br>
*/
-public abstract class PreparedStatementWrapper extends StatementWrapper implements
- PreparedStatement, ResultSetClosedEventListener {
- protected PreparedStatement preparedStatement = null;
- private boolean busy = false;
- private boolean cached = false;
+public abstract class PreparedStatementWrapper extends StatementWrapper implements PreparedStatement, ResultSetClosedEventListener {
+
+ protected PreparedStatement preparedStatement;
+ private boolean busy;
+ private boolean cached;
private int defaultMaxFieldSize;
private int defaultMaxRows;
private int defaultQueryTimeout;
@@ -50,13 +63,12 @@
/**
* Abstract class for wrapping PreparedStatement <br>
*
- * @param con Connection Wrapper <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 {
+ */
+ public PreparedStatementWrapper(Connection con, PreparedStatement statement, boolean cachingEnabled) throws SQLException {
super(con, statement);
preparedStatement = statement;
cached = cachingEnabled;
@@ -64,7 +76,6 @@
leakDetector = wrappedCon.getManagedConnection().getLeakDetector();
if (cached) {
-
defaultQueryTimeout = preparedStatement.getQueryTimeout();
defaultMaxFieldSize = preparedStatement.getMaxFieldSize();
defaultFetchSize = preparedStatement.getFetchSize();
@@ -78,8 +89,8 @@
currentFetchDirection = defaultFetchDirection;
} else {
- //Start Statement leak detection
- if(leakDetector != null) {
+ // Start Statement leak detection
+ if (leakDetector != null) {
leakDetector.startStatementLeakTracing(preparedStatement, this);
}
}
@@ -88,14 +99,14 @@
/**
* Executes the SQL statement in this <code>PreparedStatement</code> object,
* which must be an SQL <code>INSERT</code>, <code>UPDATE</code> or
- * <code>DELETE</code> statement; or an SQL statement that returns nothing,
- * such as a DDL statement.
+ * <code>DELETE</code> statement; or an SQL statement that returns nothing, such
+ * as a DDL statement.
*
- * @return either (1) the row count for <code>INSERT</code>, <code>UPDATE</code>,
- * or <code>DELETE</code> statements
- * or (2) 0 for SQL statements that return nothing
+ * @return either (1) the row count for <code>INSERT</code>,
+ * <code>UPDATE</code>, or <code>DELETE</code> 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</code> object
+ * statement returns a <code>ResultSet</code> object
*/
public int executeUpdate() throws SQLException {
return preparedStatement.executeUpdate();
@@ -104,10 +115,11 @@
/**
* Sets the designated parameter to SQL <code>NULL</code>.
* <p/>
- * <P><B>Note:</B> You must specify the parameter's SQL type.
+ * <P>
+ * <B>Note:</B> 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</code>
+ * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public void setNull(int parameterIndex, int sqlType) throws SQLException {
@@ -116,11 +128,11 @@
/**
* Sets the designated parameter to the given Java <code>boolean</code> value.
- * The driver converts this
- * to an SQL <code>BIT</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>BIT</code> value when it sends it to
+ * the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
@@ -128,12 +140,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>byte</code> value.
- * The driver converts this
- * to an SQL <code>TINYINT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>byte</code> value. The
+ * driver converts this to an SQL <code>TINYINT</code> value when it sends it to
+ * the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setByte(int parameterIndex, byte x) throws SQLException {
@@ -141,12 +153,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>short</code> value.
- * The driver converts this
- * to an SQL <code>SMALLINT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>short</code> value. The
+ * driver converts this to an SQL <code>SMALLINT</code> value when it sends it
+ * to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setShort(int parameterIndex, short x) throws SQLException {
@@ -154,12 +166,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>int</code> value.
- * The driver converts this
- * to an SQL <code>INTEGER</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>int</code> value. The
+ * driver converts this to an SQL <code>INTEGER</code> value when it sends it to
+ * the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setInt(int parameterIndex, int x) throws SQLException {
@@ -167,12 +179,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>long</code> value.
- * The driver converts this
- * to an SQL <code>BIGINT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>long</code> value. The
+ * driver converts this to an SQL <code>BIGINT</code> value when it sends it to
+ * the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setLong(int parameterIndex, long x) throws SQLException {
@@ -180,12 +192,12 @@
}
/**
- * Sets the designated parameter to the given Java <code>float</code> value.
- * The driver converts this
- * to an SQL <code>FLOAT</code> value when it sends it to the database.
+ * Sets the designated parameter to the given Java <code>float</code> value. The
+ * driver converts this to an SQL <code>FLOAT</code> value when it sends it to
+ * the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setFloat(int parameterIndex, float x) throws SQLException {
@@ -194,11 +206,11 @@
/**
* Sets the designated parameter to the given Java <code>double</code> value.
- * The driver converts this
- * to an SQL <code>DOUBLE</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>DOUBLE</code> value when it sends it
+ * to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setDouble(int parameterIndex, double x) throws SQLException {
@@ -206,12 +218,12 @@
}
/**
- * Sets the designated parameter to the given <code>java.math.BigDecimal</code> value.
- * The driver converts this to an SQL <code>NUMERIC</code> value when
- * it sends it to the database.
+ * Sets the designated parameter to the given <code>java.math.BigDecimal</code>
+ * value. The driver converts this to an SQL <code>NUMERIC</code> value when it
+ * sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
@@ -220,14 +232,13 @@
/**
* Sets the designated parameter to the given Java <code>String</code> value.
- * The driver converts this
- * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
- * (depending on the argument's
- * size relative to the driver's limits on <code>VARCHAR</code> values)
- * when it sends it to the database.
+ * The driver converts this to an SQL <code>VARCHAR</code> or
+ * <code>LONGVARCHAR</code> value (depending on the argument's size relative to
+ * the driver's limits on <code>VARCHAR</code> values) when it sends it to the
+ * database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setString(int parameterIndex, String x) throws SQLException {
@@ -235,13 +246,13 @@
}
/**
- * Sets the designated parameter to the given Java array of bytes. The driver converts
- * this to an SQL <code>VARBINARY</code> or <code>LONGVARBINARY</code>
+ * Sets the designated parameter to the given Java array of bytes. The driver
+ * converts this to an SQL <code>VARBINARY</code> or <code>LONGVARBINARY</code>
* (depending on the argument's size relative to the driver's limits on
* <code>VARBINARY</code> values) when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setBytes(int parameterIndex, byte x[]) throws SQLException {
@@ -250,11 +261,11 @@
/**
* Sets the designated parameter to the given <code>java.sql.Date</code> value.
- * The driver converts this
- * to an SQL <code>DATE</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>DATE</code> value when it sends it
+ * to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setDate(int parameterIndex, Date x) throws SQLException {
@@ -263,11 +274,11 @@
/**
* Sets the designated parameter to the given <code>java.sql.Time</code> value.
- * The driver converts this
- * to an SQL <code>TIME</code> value when it sends it to the database.
+ * The driver converts this to an SQL <code>TIME</code> value when it sends it
+ * to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setTime(int parameterIndex, Time x) throws SQLException {
@@ -275,13 +286,12 @@
}
/**
- * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
- * The driver
- * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
- * database.
+ * Sets the designated parameter to the given <code>java.sql.Timestamp</code>
+ * value. The driver converts this to an SQL <code>TIMESTAMP</code> value when
+ * it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws java.sql.SQLException if a database access error occurs
*/
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
@@ -289,21 +299,20 @@
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * 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</code> parameter, it may be more practical to send it via a
+ * <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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
+ * @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 {
@@ -311,25 +320,24 @@
}
/**
- * 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.
+ * 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</code>
* parameter, it may be more practical to send it via a
* <code>java.io.InputStream</code> 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.
+ * 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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</code> object that contains the
- * Unicode parameter value as two-byte Unicode characters
- * @param length the number of bytes in the stream
+ * @param x a <code>java.io.InputStream</code> 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
*/
@@ -339,20 +347,19 @@
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the
+ * 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</code> parameter, it may be more practical to send it via
+ * a <code>java.io.InputStream</code> object. The data will be read from the
* stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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
+ * @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 {
@@ -361,11 +368,12 @@
/**
* 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</code>.
+ * <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</code>.
*
* @throws java.sql.SQLException if a database access error occurs
*/
@@ -374,32 +382,34 @@
}
/**
- * <p>Sets the value of the designated parameter with the given object. The second
+ * <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</code> 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>
+ * 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</code>),
- * the JDBC driver should call the method <code>SQLData.writeSQL</code> to
- * write it to the SQL data stream.
- * If, on the other hand, the object is of a class implementing
- * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>Struct</code>,
- * or <code>Array</code>, the driver should pass it to the database as a
- * value of the corresponding SQL type.
+ * If the object has a custom mapping (is of a class implementing the interface
+ * <code>SQLData</code>), the JDBC driver should call the method
+ * <code>SQLData.writeSQL</code> to write it to the SQL data stream. If, on the
+ * other hand, the object is of a class implementing <code>Ref</code>,
+ * <code>Blob</code>, <code>Clob</code>, <code>Struct</code>, or
+ * <code>Array</code>, 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.
+ * <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.
+ * @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
*/
@@ -408,14 +418,14 @@
}
/**
- * Sets the value of the designated parameter with the given object.
- * This method is like the method <code>setObject</code>
- * above, except that it assumes a scale of zero.
+ * Sets the value of the designated parameter with the given object. This method
+ * is like the method <code>setObject</code> 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
+ * @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 {
@@ -423,34 +433,35 @@
}
/**
- * <p>Sets the value of the designated parameter using the given object.
- * The second parameter must be of type <code>Object</code>; therefore, the
+ * <p>
+ * Sets the value of the designated parameter using the given object. The second
+ * parameter must be of type <code>Object</code>; therefore, the
* <code>java.lang</code> equivalent objects should be used for built-in types.
* <p/>
- * <p>The JDBC specification specifies a standard mapping from
- * Java <code>Object</code> types to SQL types. The given argument
- * will be converted to the corresponding SQL type before being
- * sent to the database.
+ * <p>
+ * The JDBC specification specifies a standard mapping from Java
+ * <code>Object</code> 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>
+ * 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</code>,
- * the JDBC driver should call the method <code>SQLData.writeSQL</code>
- * to write it to the SQL data stream.
- * If, on the other hand, the object is of a class implementing
- * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>Struct</code>,
- * or <code>Array</code>, the driver should pass it to the database as a
- * value of the corresponding SQL type.
+ * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write
+ * it to the SQL data stream. If, on the other hand, the object is of a class
+ * implementing <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,
+ * <code>Struct</code>, or <code>Array</code>, 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.
+ * 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
+ * @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
+ * of the given object is ambiguous
*/
public void setObject(int parameterIndex, Object x) throws SQLException {
preparedStatement.setObject(parameterIndex, x);
@@ -458,23 +469,22 @@
/**
* Executes the SQL statement in this <code>PreparedStatement</code> object,
- * which may be any kind of SQL statement.
- * Some prepared statements return multiple results; the <code>execute</code>
- * method handles these complex statements as well as the simpler
- * form of statements handled by the methods <code>executeQuery</code>
- * and <code>executeUpdate</code>.
+ * which may be any kind of SQL statement. Some prepared statements return
+ * multiple results; the <code>execute</code> method handles these complex
+ * statements as well as the simpler form of statements handled by the methods
+ * <code>executeQuery</code> and <code>executeUpdate</code>.
* <p/>
- * The <code>execute</code> method returns a <code>boolean</code> to
- * indicate the form of the first result. You must call either the method
- * <code>getResultSet</code> or <code>getUpdateCount</code>
- * to retrieve the result; you must call <code>getMoreResults</code> to
- * move to any subsequent result(s).
+ * The <code>execute</code> method returns a <code>boolean</code> to indicate
+ * the form of the first result. You must call either the method
+ * <code>getResultSet</code> or <code>getUpdateCount</code> to retrieve the
+ * result; you must call <code>getMoreResults</code> to move to any subsequent
+ * result(s).
*
* @return <code>true</code> if the first result is a <code>ResultSet</code>
- * object; <code>false</code> 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
+ * object; <code>false</code> 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
@@ -485,8 +495,8 @@
}
/**
- * Adds a set of parameters to this <code>PreparedStatement</code>
- * object's batch of commands.
+ * Adds a set of parameters to this <code>PreparedStatement</code> object's
+ * batch of commands.
*
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.Statement#addBatch
@@ -497,22 +507,21 @@
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object, which
+ * is the given number of characters long. When a very large UNICODE value is
+ * input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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</code> object that contains the
- * Unicode data
- * @param length the number of characters in the stream
+ * @param reader the <code>java.io.Reader</code> 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
*/
@@ -522,9 +531,8 @@
/**
* Sets the designated parameter to the given
- * <code>REF(<structured-type>)</code> value.
- * The driver converts this to an SQL <code>REF</code> value when it
- * sends it to the database.
+ * <code>REF(<structured-type>)</code> value. The driver converts this to
+ * an SQL <code>REF</code> 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</code> value
@@ -536,9 +544,9 @@
}
/**
- * Sets the designated parameter to the given <code>Blob</code> object.
- * The driver converts this to an SQL <code>BLOB</code> value when it
- * sends it to the database.
+ * Sets the designated parameter to the given <code>Blob</code> object. The
+ * driver converts this to an SQL <code>BLOB</code> value when it sends it to
+ * the database.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
@@ -550,9 +558,9 @@
}
/**
- * Sets the designated parameter to the given <code>Clob</code> object.
- * The driver converts this to an SQL <code>CLOB</code> value when it
- * sends it to the database.
+ * Sets the designated parameter to the given <code>Clob</code> object. The
+ * driver converts this to an SQL <code>CLOB</code> value when it sends it to
+ * the database.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
@@ -564,12 +572,13 @@
}
/**
- * Sets the designated parameter to the given <code>Array</code> object.
- * The driver converts this to an SQL <code>ARRAY</code> value when it
- * sends it to the database.
+ * Sets the designated parameter to the given <code>Array</code> object. The
+ * driver converts this to an SQL <code>ARRAY</code> value when it sends it to
+ * the database.
*
* @param i the first parameter is 1, the second is 2, ...
- * @param x an <code>Array</code> object that maps an SQL <code>ARRAY</code> value
+ * @param x an <code>Array</code> object that maps an SQL <code>ARRAY</code>
+ * value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -578,25 +587,24 @@
}
/**
- * Retrieves a <code>ResultSetMetaData</code> object that contains
- * information about the columns of the <code>ResultSet</code> object
- * that will be returned when this <code>PreparedStatement</code> object
- * is executed.
+ * Retrieves a <code>ResultSetMetaData</code> object that contains information
+ * about the columns of the <code>ResultSet</code> object that will be returned
+ * when this <code>PreparedStatement</code> object is executed.
* <p/>
* Because a <code>PreparedStatement</code> object is precompiled, it is
- * possible to know about the <code>ResultSet</code> object that it will
- * return without having to execute it. Consequently, it is possible
- * to invoke the method <code>getMetaData</code> on a
- * <code>PreparedStatement</code> object rather than waiting to execute
- * it and then invoking the <code>ResultSet.getMetaData</code> method
- * on the <code>ResultSet</code> object that is returned.
+ * possible to know about the <code>ResultSet</code> object that it will return
+ * without having to execute it. Consequently, it is possible to invoke the
+ * method <code>getMetaData</code> on a <code>PreparedStatement</code> object
+ * rather than waiting to execute it and then invoking the
+ * <code>ResultSet.getMetaData</code> method on the <code>ResultSet</code>
+ * object that is returned.
* <p/>
- * <B>NOTE:</B> Using this method may be expensive for some drivers due
- * to the lack of underlying DBMS support.
+ * <B>NOTE:</B> Using this method may be expensive for some drivers due to the
+ * lack of underlying DBMS support.
*
* @return the description of a <code>ResultSet</code> object's columns or
- * <code>null</code> if the driver cannot return a
- * <code>ResultSetMetaData</code> object
+ * <code>null</code> if the driver cannot return a
+ * <code>ResultSetMetaData</code> object
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -606,18 +614,18 @@
/**
* Sets the designated parameter to the given <code>java.sql.Date</code> value,
- * using the given <code>Calendar</code> object. The driver uses
- * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
- * which the driver then sends to the database. With
- * a <code>Calendar</code> object, the driver can calculate the date
- * taking into account a custom timezone. If no
- * <code>Calendar</code> object is specified, the driver uses the default
- * timezone, which is that of the virtual machine running the application.
+ * using the given <code>Calendar</code> object. The driver uses the
+ * <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
+ * which the driver then sends to the database. With a <code>Calendar</code>
+ * object, the driver can calculate the date taking into account a custom
+ * timezone. If no <code>Calendar</code> 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</code> object the driver will use
- * to construct the date
+ * @param x the parameter value
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the date
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -627,18 +635,18 @@
/**
* Sets the designated parameter to the given <code>java.sql.Time</code> value,
- * using the given <code>Calendar</code> object. The driver uses
- * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
- * which the driver then sends to the database. With
- * a <code>Calendar</code> object, the driver can calculate the time
- * taking into account a custom timezone. If no
- * <code>Calendar</code> object is specified, the driver uses the default
- * timezone, which is that of the virtual machine running the application.
+ * using the given <code>Calendar</code> object. The driver uses the
+ * <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
+ * which the driver then sends to the database. With a <code>Calendar</code>
+ * object, the driver can calculate the time taking into account a custom
+ * timezone. If no <code>Calendar</code> 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</code> object the driver will use
- * to construct the time
+ * @param x the parameter value
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the time
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -647,19 +655,19 @@
}
/**
- * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
- * using the given <code>Calendar</code> object. The driver uses
- * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
- * which the driver then sends to the database. With a
- * <code>Calendar</code> object, the driver can calculate the timestamp
- * taking into account a custom timezone. If no
- * <code>Calendar</code> object is specified, the driver uses the default
- * timezone, which is that of the virtual machine running the application.
+ * Sets the designated parameter to the given <code>java.sql.Timestamp</code>
+ * value, using the given <code>Calendar</code> object. The driver uses the
+ * <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code>
+ * value, which the driver then sends to the database. With a
+ * <code>Calendar</code> object, the driver can calculate the timestamp taking
+ * into account a custom timezone. If no <code>Calendar</code> 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</code> object the driver will use
- * to construct the timestamp
+ * @param x the parameter value
+ * @param cal the <code>Calendar</code> object the driver will use to construct
+ * the timestamp
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -668,29 +676,27 @@
}
/**
- * Sets the designated parameter to SQL <code>NULL</code>.
- * This version of the method <code>setNull</code> 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.
+ * Sets the designated parameter to SQL <code>NULL</code>. This version of the
+ * method <code>setNull</code> 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><B>Note:</B> 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>
+ * <B>Note:</B> 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.
+ * 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</code>
- * @param typeName the fully-qualified name of an SQL user-defined type;
- * ignored if the parameter is not a user-defined type or REF
+ * @param sqlType a value from <code>java.sql.Types</code>
+ * @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
*/
@@ -700,11 +706,11 @@
/**
* Sets the designated parameter to the given <code>java.net.URL</code> value.
- * The driver converts this to an SQL <code>DATALINK</code> value
- * when it sends it to the database.
+ * The driver converts this to an SQL <code>DATALINK</code> 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</code> object to be set
+ * @param x the <code>java.net.URL</code> object to be set
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -717,8 +723,8 @@
* <code>PreparedStatement</code> object's parameters.
*
* @return a <code>ParameterMetaData</code> object that contains information
- * about the number, types and properties of this
- * <code>PreparedStatement</code> object's parameters
+ * about the number, types and properties of this <code>PreparedStatement</code>
+ * object's parameters
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.ParameterMetaData
* @since 1.4
@@ -740,11 +746,11 @@
} 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
+ 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);
}
}
@@ -757,13 +763,14 @@
public void close() throws SQLException {
if (!cached) {
- //Stop leak tracing
- if(leakDetector != null) {
+ // 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
+ // 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();
@@ -795,8 +802,9 @@
public void closeOnCompletion() throws SQLException {
if (DataSourceObjectBuilder.isJDBC41()) {
- if(!cached) {
- //If statement caching is not turned on, call the driver implementation directly
+ if (!cached) {
+ // If statement caching is not turned on, call the driver implementation
+ // directly
if (leakDetector != null) {
_logger.log(Level.INFO, "jdbc.invalid_operation.close_on_completion");
throw new UnsupportedOperationException("Not supported yet.");
@@ -810,7 +818,7 @@
public boolean isCloseOnCompletion() throws SQLException {
if (DataSourceObjectBuilder.isJDBC41()) {
- if(cached) {
+ if (cached) {
return getCloseOnCompletion();
}
}
@@ -847,8 +855,8 @@
currentFetchSize = rows;
}
- public void setCached(boolean cached){
- this.cached = cached;
+ public void setCached(boolean cached) {
+ this.cached = cached;
}
public boolean isValid() {
@@ -860,14 +868,14 @@
}
public void incrementResultSetReferenceCount() {
- //Update resultSetCount to be used in case of jdbc41 closeOnCompletion
- if (DataSourceObjectBuilder.isJDBC41() && getCached()) {
+ // Update resultSetCount to be used in case of jdbc41 closeOnCompletion
+ if (isJDBC41() && getCached()) {
incrementResultSetCount();
}
}
public void resultSetClosed() throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41() && getCached()) {
+ if (isJDBC41() && getCached()) {
decrementResultSetCount();
if (getCloseOnCompletion() && getResultSetCount() == 0) {
ConnectionHolder wrappedCon = (ConnectionHolder) getConnection();
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ResultSetWrapper.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ResultSetWrapper.java
index d640969..23c0e31 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ResultSetWrapper.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/ResultSetWrapper.java
@@ -16,63 +16,71 @@
package com.sun.gjc.spi.base;
-import com.sun.gjc.util.MethodExecutor;
-import com.sun.gjc.util.ResultSetClosedEventListener;
-import com.sun.logging.LogDomains;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
-import java.sql.*;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;
import java.util.logging.Logger;
+import com.sun.gjc.util.MethodExecutor;
+import com.sun.gjc.util.ResultSetClosedEventListener;
+import com.sun.logging.LogDomains;
/**
* Abstract class for ResultSet Wrapper <br>
*/
public abstract class ResultSetWrapper implements ResultSet {
- protected ResultSet resultSet = null;
- protected Statement statement = null;
- private MethodExecutor executor = null;
- protected final static Logger _logger;
- private ResultSetClosedEventListener eventListener = null;
+ protected final static Logger _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- static {
- _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- }
+ protected ResultSet resultSet;
+ protected Statement statement;
+ private MethodExecutor executor;
+
+ private ResultSetClosedEventListener eventListener;
/**
* Abstract class for wrapping Statement<br>
*
* @param stmt Statement that is to be wrapped<br>
- * @param rs ResultSet that is to be wraped<br>
+ * @param rs ResultSet that is to be wraped<br>
*/
public ResultSetWrapper(Statement stmt, ResultSet rs) {
resultSet = rs;
statement = stmt;
executor = new MethodExecutor();
- if(stmt instanceof ResultSetClosedEventListener) {
+ if (stmt instanceof ResultSetClosedEventListener) {
eventListener = (ResultSetClosedEventListener) stmt;
}
}
/**
- * Moves the cursor down one row from its current position.
- * A <code>ResultSet</code> cursor is initially positioned
- * before the first row; the first call to the method
- * <code>next</code> makes the first row the current row; the
- * second call makes the second row the current row, and so on.
+ * Moves the cursor down one row from its current position. A
+ * <code>ResultSet</code> cursor is initially positioned before the first row;
+ * the first call to the method <code>next</code> makes the first row the
+ * current row; the second call makes the second row the current row, and so on.
* <p/>
- * <P>If an input stream is open for the current row, a call
- * to the method <code>next</code> will
- * implicitly close it. A <code>ResultSet</code> object's
+ * <P>
+ * If an input stream is open for the current row, a call to the method
+ * <code>next</code> will implicitly close it. A <code>ResultSet</code> object's
* warning chain is cleared when a new row is read.
*
- * @return <code>true</code> if the new current row is valid;
- * <code>false</code> if there are no more rows
+ * @return <code>true</code> if the new current row is valid; <code>false</code>
+ * if there are no more rows
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean next() throws SQLException {
@@ -80,17 +88,16 @@
}
/**
- * Releases this <code>ResultSet</code> object's database and
- * JDBC resources immediately instead of waiting for
- * this to happen when it is automatically closed.
+ * Releases this <code>ResultSet</code> object's database and JDBC resources
+ * immediately instead of waiting for this to happen when it is automatically
+ * closed.
* <p/>
- * <P><B>Note:</B> A <code>ResultSet</code> object
- * is automatically closed by the
- * <code>Statement</code> object that generated it when
- * that <code>Statement</code> object is closed,
- * re-executed, or is used to retrieve the next result from a
- * sequence of multiple results. A <code>ResultSet</code> object
- * is also automatically closed when it is garbage collected.
+ * <P>
+ * <B>Note:</B> A <code>ResultSet</code> object is automatically closed by the
+ * <code>Statement</code> object that generated it when that
+ * <code>Statement</code> object is closed, re-executed, or is used to retrieve
+ * the next result from a sequence of multiple results. A <code>ResultSet</code>
+ * object is also automatically closed when it is garbage collected.
*
* @throws java.sql.SQLException if a database access error occurs
*/
@@ -102,15 +109,13 @@
}
/**
- * Reports whether
- * the last column read had a value of SQL <code>NULL</code>.
- * Note that you must first call one of the getter methods
- * on a column to try to read its value and then call
- * the method <code>wasNull</code> to see if the value read was
- * SQL <code>NULL</code>.
+ * Reports whether the last column read had a value of SQL <code>NULL</code>.
+ * Note that you must first call one of the getter methods on a column to try to
+ * read its value and then call the method <code>wasNull</code> to see if the
+ * value read was SQL <code>NULL</code>.
*
* @return <code>true</code> if the last column value read was SQL
- * <code>NULL</code> and <code>false</code> otherwise
+ * <code>NULL</code> and <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean wasNull() throws SQLException {
@@ -118,13 +123,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>String</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>String</code> in the Java
+ * programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public String getString(int columnIndex) throws SQLException {
@@ -132,13 +137,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>boolean</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>boolean</code> in the Java
+ * programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>false</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>false</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean getBoolean(int columnIndex) throws SQLException {
@@ -146,13 +151,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>byte</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>byte</code> in the Java programming
+ * language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public byte getByte(int columnIndex) throws SQLException {
@@ -160,13 +165,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>short</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>short</code> in the Java programming
+ * language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public short getShort(int columnIndex) throws SQLException {
@@ -174,13 +179,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * an <code>int</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>int</code> in the Java programming
+ * language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public int getInt(int columnIndex) throws SQLException {
@@ -188,13 +193,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>long</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>long</code> in the Java programming
+ * language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public long getLong(int columnIndex) throws SQLException {
@@ -202,13 +207,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>float</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>float</code> in the Java programming
+ * language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public float getFloat(int columnIndex) throws SQLException {
@@ -216,13 +221,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>double</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>double</code> in the Java
+ * programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public double getDouble(int columnIndex) throws SQLException {
@@ -230,14 +235,14 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.BigDecimal</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.BigDecimal</code> in the
+ * Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param scale the number of digits to the right of the decimal point
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @param scale the number of digits to the right of the decimal point
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
* @deprecated
*/
@@ -247,14 +252,14 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>byte</code> array in the Java programming language.
- * The bytes represent the raw values returned by the driver.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>byte</code> array in the Java
+ * programming language. The bytes represent the raw values returned by the
+ * driver.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public byte[] getBytes(int columnIndex) throws SQLException {
@@ -262,13 +267,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.Date</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Date</code> object in the
+ * Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public Date getDate(int columnIndex) throws SQLException {
@@ -276,13 +281,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.Time</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Time</code> object in the
+ * Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public Time getTime(int columnIndex) throws SQLException {
@@ -290,13 +295,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.Timestamp</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object in
+ * the Java programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public Timestamp getTimestamp(int columnIndex) throws SQLException {
@@ -304,26 +309,23 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a stream of ASCII characters. The value can then be read in chunks from the
- * stream. This method is particularly
- * suitable for retrieving large <char>LONGVARCHAR</char> values.
- * The JDBC driver will
- * do any necessary conversion from the database format into ASCII.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a stream of ASCII characters. The value can
+ * then be read in chunks from the stream. This method is particularly suitable
+ * for retrieving large <char>LONGVARCHAR</char> values. The JDBC driver will do
+ * any necessary conversion from the database format into ASCII.
* <p/>
- * <P><B>Note:</B> All the data in the returned stream must be
- * read prior to getting the value of any other column. The next
- * call to a getter method implicitly closes the stream. Also, a
- * stream may return <code>0</code> when the method
- * <code>InputStream.available</code>
- * is called whether there is data available or not.
+ * <P>
+ * <B>Note:</B> All the data in the returned stream must be read prior to
+ * getting the value of any other column. The next call to a getter method
+ * implicitly closes the stream. Also, a stream may return <code>0</code> when
+ * the method <code>InputStream.available</code> is called whether there is data
+ * available or not.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return a Java input stream that delivers the database column value
- * as a stream of one-byte ASCII characters;
- * if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return a Java input stream that delivers the database column value as a
+ * stream of one-byte ASCII characters; if the value is SQL <code>NULL</code>,
+ * the value returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getAsciiStream(int columnIndex) throws SQLException {
@@ -331,32 +333,29 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * as a stream of two-byte Unicode characters. The first byte is
- * the high byte; the second byte is the low byte.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as as a stream of two-byte Unicode characters.
+ * The first byte is the high byte; the second byte is the low byte.
* <p/>
- * The value can then be read in chunks from the
- * stream. This method is particularly
- * suitable for retrieving large <code>LONGVARCHAR</code>values. The
- * JDBC driver will do any necessary conversion from the database
- * format into Unicode.
+ * The value can then be read in chunks from the stream. This method is
+ * particularly suitable for retrieving large <code>LONGVARCHAR</code>values.
+ * The JDBC driver will do any necessary conversion from the database format
+ * into Unicode.
* <p/>
- * <P><B>Note:</B> All the data in the returned stream must be
- * read prior to getting the value of any other column. The next
- * call to a getter method implicitly closes the stream.
- * Also, a stream may return <code>0</code> when the method
- * <code>InputStream.available</code>
- * is called, whether there is data available or not.
+ * <P>
+ * <B>Note:</B> All the data in the returned stream must be read prior to
+ * getting the value of any other column. The next call to a getter method
+ * implicitly closes the stream. Also, a stream may return <code>0</code> when
+ * the method <code>InputStream.available</code> is called, whether there is
+ * data available or not.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return a Java input stream that delivers the database column value
- * as a stream of two-byte Unicode characters;
- * if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code>
+ * @return a Java input stream that delivers the database column value as a
+ * stream of two-byte Unicode characters; if the value is SQL <code>NULL</code>,
+ * the value returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
* @deprecated use <code>getCharacterStream</code> in place of
- * <code>getUnicodeStream</code>
+ * <code>getUnicodeStream</code>
*/
@Deprecated
public InputStream getUnicodeStream(int columnIndex) throws SQLException {
@@ -364,24 +363,22 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a binary stream of
- * uninterpreted bytes. The value can then be read in chunks from the
- * stream. This method is particularly
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a binary stream of uninterpreted bytes. The
+ * value can then be read in chunks from the stream. This method is particularly
* suitable for retrieving large <code>LONGVARBINARY</code> values.
* <p/>
- * <P><B>Note:</B> All the data in the returned stream must be
- * read prior to getting the value of any other column. The next
- * call to a getter method implicitly closes the stream. Also, a
- * stream may return <code>0</code> when the method
- * <code>InputStream.available</code>
- * is called whether there is data available or not.
+ * <P>
+ * <B>Note:</B> All the data in the returned stream must be read prior to
+ * getting the value of any other column. The next call to a getter method
+ * implicitly closes the stream. Also, a stream may return <code>0</code> when
+ * the method <code>InputStream.available</code> is called whether there is data
+ * available or not.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return a Java input stream that delivers the database column value
- * as a stream of uninterpreted bytes;
- * if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code>
+ * @return a Java input stream that delivers the database column value as a
+ * stream of uninterpreted bytes; if the value is SQL <code>NULL</code>, the
+ * value returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getBinaryStream(int columnIndex) throws SQLException {
@@ -389,13 +386,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>String</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>String</code> in the Java
+ * programming language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public String getString(String columnName) throws SQLException {
@@ -403,13 +400,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>boolean</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>boolean</code> in the Java
+ * programming language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>false</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>false</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public boolean getBoolean(String columnName) throws SQLException {
@@ -417,13 +414,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>byte</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>byte</code> in the Java programming
+ * language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public byte getByte(String columnName) throws SQLException {
@@ -431,13 +428,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>short</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>short</code> in the Java programming
+ * language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public short getShort(String columnName) throws SQLException {
@@ -445,13 +442,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * an <code>int</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>int</code> in the Java programming
+ * language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public int getInt(String columnName) throws SQLException {
@@ -459,13 +456,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>long</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>long</code> in the Java programming
+ * language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public long getLong(String columnName) throws SQLException {
@@ -473,13 +470,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>float</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>float</code> in the Java programming
+ * language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public float getFloat(String columnName) throws SQLException {
@@ -487,13 +484,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>double</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>double</code> in the Java
+ * programming language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>0</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>0</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public double getDouble(String columnName) throws SQLException {
@@ -501,14 +498,14 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.math.BigDecimal</code> in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.math.BigDecimal</code> in the
+ * Java programming language.
*
* @param columnName the SQL name of the column
- * @param scale the number of digits to the right of the decimal point
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @param scale the number of digits to the right of the decimal point
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
* @deprecated
*/
@@ -518,14 +515,14 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>byte</code> array in the Java programming language.
- * The bytes represent the raw values returned by the driver.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>byte</code> array in the Java
+ * programming language. The bytes represent the raw values returned by the
+ * driver.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public byte[] getBytes(String columnName) throws SQLException {
@@ -533,13 +530,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.Date</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Date</code> object in the
+ * Java programming language.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public Date getDate(String columnName) throws SQLException {
@@ -547,14 +544,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.Time</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Time</code> object in the
+ * Java programming language.
*
* @param columnName the SQL name of the column
- * @return the column value;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public Time getTime(String columnName) throws SQLException {
@@ -562,13 +558,12 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>java.sql.Timestamp</code> object.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object.
*
* @param columnName the SQL name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public Timestamp getTimestamp(String columnName) throws SQLException {
@@ -576,25 +571,23 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a stream of
- * ASCII characters. The value can then be read in chunks from the
- * stream. This method is particularly
- * suitable for retrieving large <code>LONGVARCHAR</code> values.
- * The JDBC driver will
- * do any necessary conversion from the database format into ASCII.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a stream of ASCII characters. The value can
+ * then be read in chunks from the stream. This method is particularly suitable
+ * for retrieving large <code>LONGVARCHAR</code> values. The JDBC driver will do
+ * any necessary conversion from the database format into ASCII.
* <p/>
- * <P><B>Note:</B> All the data in the returned stream must be
- * read prior to getting the value of any other column. The next
- * call to a getter method implicitly closes the stream. Also, a
- * stream may return <code>0</code> when the method <code>available</code>
- * is called whether there is data available or not.
+ * <P>
+ * <B>Note:</B> All the data in the returned stream must be read prior to
+ * getting the value of any other column. The next call to a getter method
+ * implicitly closes the stream. Also, a stream may return <code>0</code> when
+ * the method <code>available</code> is called whether there is data available
+ * or not.
*
* @param columnName the SQL name of the column
- * @return a Java input stream that delivers the database column value
- * as a stream of one-byte ASCII characters.
- * If the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code>.
+ * @return a Java input stream that delivers the database column value as a
+ * stream of one-byte ASCII characters. If the value is SQL <code>NULL</code>,
+ * the value returned is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getAsciiStream(String columnName) throws SQLException {
@@ -602,29 +595,26 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a stream of two-byte
- * Unicode characters. The first byte is the high byte; the second
- * byte is the low byte.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a stream of two-byte Unicode characters. The
+ * first byte is the high byte; the second byte is the low byte.
* <p/>
- * The value can then be read in chunks from the
- * stream. This method is particularly
- * suitable for retrieving large <code>LONGVARCHAR</code> values.
- * The JDBC technology-enabled driver will
- * do any necessary conversion from the database format into Unicode.
+ * The value can then be read in chunks from the stream. This method is
+ * particularly suitable for retrieving large <code>LONGVARCHAR</code> values.
+ * The JDBC technology-enabled driver will do any necessary conversion from the
+ * database format into Unicode.
* <p/>
- * <P><B>Note:</B> All the data in the returned stream must be
- * read prior to getting the value of any other column. The next
- * call to a getter method implicitly closes the stream.
- * Also, a stream may return <code>0</code> when the method
- * <code>InputStream.available</code> is called, whether there
- * is data available or not.
+ * <P>
+ * <B>Note:</B> All the data in the returned stream must be read prior to
+ * getting the value of any other column. The next call to a getter method
+ * implicitly closes the stream. Also, a stream may return <code>0</code> when
+ * the method <code>InputStream.available</code> is called, whether there is
+ * data available or not.
*
* @param columnName the SQL name of the column
- * @return a Java input stream that delivers the database column value
- * as a stream of two-byte Unicode characters.
- * If the value is SQL <code>NULL</code>, the value returned
- * is <code>null</code>.
+ * @return a Java input stream that delivers the database column value as a
+ * stream of two-byte Unicode characters. If the value is SQL <code>NULL</code>,
+ * the value returned is <code>null</code>.
* @throws java.sql.SQLException if a database access error occurs
* @deprecated use <code>getCharacterStream</code> instead
*/
@@ -634,24 +624,23 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a stream of uninterpreted
- * <code>byte</code>s.
- * The value can then be read in chunks from the
- * stream. This method is particularly
- * suitable for retrieving large <code>LONGVARBINARY</code>
- * values.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a stream of uninterpreted
+ * <code>byte</code>s. The value can then be read in chunks from the stream.
+ * This method is particularly suitable for retrieving large
+ * <code>LONGVARBINARY</code> values.
* <p/>
- * <P><B>Note:</B> All the data in the returned stream must be
- * read prior to getting the value of any other column. The next
- * call to a getter method implicitly closes the stream. Also, a
- * stream may return <code>0</code> when the method <code>available</code>
- * is called whether there is data available or not.
+ * <P>
+ * <B>Note:</B> All the data in the returned stream must be read prior to
+ * getting the value of any other column. The next call to a getter method
+ * implicitly closes the stream. Also, a stream may return <code>0</code> when
+ * the method <code>available</code> is called whether there is data available
+ * or not.
*
* @param columnName the SQL name of the column
- * @return a Java input stream that delivers the database column value
- * as a stream of uninterpreted bytes;
- * if the value is SQL <code>NULL</code>, the result is <code>null</code>
+ * @return a Java input stream that delivers the database column value as a
+ * stream of uninterpreted bytes; if the value is SQL <code>NULL</code>, the
+ * result is <code>null</code>
* @throws java.sql.SQLException if a database access error occurs
*/
public InputStream getBinaryStream(String columnName) throws SQLException {
@@ -659,37 +648,34 @@
}
/**
- * Retrieves the first warning reported by calls on this
- * <code>ResultSet</code> object.
- * Subsequent warnings on this <code>ResultSet</code> object
- * will be chained to the <code>SQLWarning</code> object that
- * this method returns.
+ * Retrieves the first warning reported by calls on this <code>ResultSet</code>
+ * object. Subsequent warnings on this <code>ResultSet</code> object will be
+ * chained to the <code>SQLWarning</code> object that this method returns.
* <p/>
- * <P>The warning chain is automatically cleared each time a new
- * row is read. This method may not be called on a <code>ResultSet</code>
- * object that has been closed; doing so will cause an
- * <code>SQLException</code> to be thrown.
+ * <P>
+ * The warning chain is automatically cleared each time a new row is read. This
+ * method may not be called on a <code>ResultSet</code> object that has been
+ * closed; doing so will cause an <code>SQLException</code> to be thrown.
* <p/>
- * <B>Note:</B> This warning chain only covers warnings caused
- * by <code>ResultSet</code> methods. Any warning caused by
- * <code>Statement</code> methods
- * (such as reading OUT parameters) will be chained on the
+ * <B>Note:</B> This warning chain only covers warnings caused by
+ * <code>ResultSet</code> methods. Any warning caused by <code>Statement</code>
+ * methods (such as reading OUT parameters) will be chained on the
* <code>Statement</code> object.
*
* @return the first <code>SQLWarning</code> object reported or
- * <code>null</code> if there are none
- * @throws java.sql.SQLException if a database access error occurs or this method is
- * called on a closed result set
+ * <code>null</code> if there are none
+ * @throws java.sql.SQLException if a database access error occurs or this
+ * method is called on a closed result set
*/
public SQLWarning getWarnings() throws SQLException {
return resultSet.getWarnings();
}
/**
- * Clears all warnings reported on this <code>ResultSet</code> object.
- * After this method is called, the method <code>getWarnings</code>
- * returns <code>null</code> until a new warning is
- * reported for this <code>ResultSet</code> object.
+ * Clears all warnings reported on this <code>ResultSet</code> object. After
+ * this method is called, the method <code>getWarnings</code> returns
+ * <code>null</code> until a new warning is reported for this
+ * <code>ResultSet</code> object.
*
* @throws java.sql.SQLException if a database access error occurs
*/
@@ -701,20 +687,22 @@
* Retrieves the name of the SQL cursor used by this <code>ResultSet</code>
* object.
* <p/>
- * <P>In SQL, a result table is retrieved through a cursor that is
- * named. The current row of a result set can be updated or deleted
- * using a positioned update/delete statement that references the
- * cursor name. To insure that the cursor has the proper isolation
- * level to support update, the cursor's <code>SELECT</code> statement
- * should be of the form <code>SELECT FOR UPDATE</code>. If
- * <code>FOR UPDATE</code> is omitted, the positioned updates may fail.
+ * <P>
+ * In SQL, a result table is retrieved through a cursor that is named. The
+ * current row of a result set can be updated or deleted using a positioned
+ * update/delete statement that references the cursor name. To insure that the
+ * cursor has the proper isolation level to support update, the cursor's
+ * <code>SELECT</code> statement should be of the form
+ * <code>SELECT FOR UPDATE</code>. If <code>FOR UPDATE</code> is omitted, the
+ * positioned updates may fail.
* <p/>
- * <P>The JDBC API supports this SQL feature by providing the name of the
- * SQL cursor used by a <code>ResultSet</code> object.
- * The current row of a <code>ResultSet</code> object
- * is also the current row of this SQL cursor.
+ * <P>
+ * The JDBC API supports this SQL feature by providing the name of the SQL
+ * cursor used by a <code>ResultSet</code> object. The current row of a
+ * <code>ResultSet</code> object is also the current row of this SQL cursor.
* <p/>
- * <P><B>Note:</B> If positioned update is not supported, a
+ * <P>
+ * <B>Note:</B> If positioned update is not supported, a
* <code>SQLException</code> is thrown.
*
* @return the SQL name for this <code>ResultSet</code> object's cursor
@@ -725,8 +713,8 @@
}
/**
- * Retrieves the number, types and properties of
- * this <code>ResultSet</code> object's columns.
+ * Retrieves the number, types and properties of this <code>ResultSet</code>
+ * object's columns.
*
* @return the description of this <code>ResultSet</code> object's columns
* @throws java.sql.SQLException if a database access error occurs
@@ -736,25 +724,25 @@
}
/**
- * <p>Gets the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * an <code>Object</code> in the Java programming language.
+ * <p>
+ * Gets the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>Object</code> in the Java
+ * programming language.
* <p/>
- * <p>This method will return the value of the given column as a
- * Java object. The type of the Java object will be the default
- * Java object type corresponding to the column's SQL type,
- * following the mapping for built-in types specified in the JDBC
- * specification. If the value is an SQL <code>NULL</code>,
- * the driver returns a Java <code>null</code>.
+ * <p>
+ * This method will return the value of the given column as a Java object. The
+ * type of the Java object will be the default Java object type corresponding to
+ * the column's SQL type, following the mapping for built-in types specified in
+ * the JDBC specification. If the value is an SQL <code>NULL</code>, the driver
+ * returns a Java <code>null</code>.
* <p/>
- * <p>This method may also be used to read database-specific
- * abstract data types.
+ * <p>
+ * This method may also be used to read database-specific abstract data types.
* <p/>
- * In the JDBC 2.0 API, the behavior of method
- * <code>getObject</code> is extended to materialize
- * data of SQL user-defined types. When a column contains
- * a structured or distinct value, the behavior of this method is as
- * if it were a call to: <code>getObject(columnIndex,
+ * In the JDBC 2.0 API, the behavior of method <code>getObject</code> is
+ * extended to materialize data of SQL user-defined types. When a column
+ * contains a structured or distinct value, the behavior of this method is as if
+ * it were a call to: <code>getObject(columnIndex,
* this.getStatement().getConnection().getTypeMap())</code>.
*
* @param columnIndex the first column is 1, the second is 2, ...
@@ -766,25 +754,24 @@
}
/**
- * <p>Gets the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * an <code>Object</code> in the Java programming language.
+ * <p>
+ * Gets the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>Object</code> in the Java
+ * programming language.
* <p/>
- * <p>This method will return the value of the given column as a
- * Java object. The type of the Java object will be the default
- * Java object type corresponding to the column's SQL type,
- * following the mapping for built-in types specified in the JDBC
- * specification. If the value is an SQL <code>NULL</code>,
- * the driver returns a Java <code>null</code>.
+ * <p>
+ * This method will return the value of the given column as a Java object. The
+ * type of the Java object will be the default Java object type corresponding to
+ * the column's SQL type, following the mapping for built-in types specified in
+ * the JDBC specification. If the value is an SQL <code>NULL</code>, the driver
+ * returns a Java <code>null</code>.
* <p/>
- * This method may also be used to read database-specific
- * abstract data types.
+ * This method may also be used to read database-specific abstract data types.
* <p/>
- * In the JDBC 2.0 API, the behavior of the method
- * <code>getObject</code> is extended to materialize
- * data of SQL user-defined types. When a column contains
- * a structured or distinct value, the behavior of this method is as
- * if it were a call to: <code>getObject(columnIndex,
+ * In the JDBC 2.0 API, the behavior of the method <code>getObject</code> is
+ * extended to materialize data of SQL user-defined types. When a column
+ * contains a structured or distinct value, the behavior of this method is as if
+ * it were a call to: <code>getObject(columnIndex,
* this.getStatement().getConnection().getTypeMap())</code>.
*
* @param columnName the SQL name of the column
@@ -801,22 +788,21 @@
*
* @param columnName the name of the column
* @return the column index of the given column name
- * @throws java.sql.SQLException if the <code>ResultSet</code> object
- * does not contain <code>columnName</code> or a database access error occurs
+ * @throws java.sql.SQLException if the <code>ResultSet</code> object does not
+ * contain <code>columnName</code> or a database access error occurs
*/
public int findColumn(String columnName) throws SQLException {
return resultSet.findColumn(columnName);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a
- * <code>java.io.Reader</code> object.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.io.Reader</code> object.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return a <code>java.io.Reader</code> object that contains the column
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language.
+ * @return a <code>java.io.Reader</code> object that contains the column value;
+ * if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -825,14 +811,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a
- * <code>java.io.Reader</code> object.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.io.Reader</code> object.
*
* @param columnName the name of the column
- * @return a <code>java.io.Reader</code> object that contains the column
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language
+ * @return a <code>java.io.Reader</code> object that contains the column value;
+ * if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -841,14 +826,14 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a
- * <code>java.math.BigDecimal</code> with full precision.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.math.BigDecimal</code> with
+ * full precision.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value (full precision);
- * if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language.
+ * @return the column value (full precision); if the value is SQL
+ * <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -857,14 +842,14 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a
- * <code>java.math.BigDecimal</code> with full precision.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.math.BigDecimal</code> with
+ * full precision.
*
* @param columnName the column name
- * @return the column value (full precision);
- * if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language.
+ * @return the column value (full precision); if the value is SQL
+ * <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language.
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -873,12 +858,12 @@
}
/**
- * Retrieves whether the cursor is before the first row in
- * this <code>ResultSet</code> object.
+ * Retrieves whether the cursor is before the first row in this
+ * <code>ResultSet</code> object.
*
* @return <code>true</code> if the cursor is before the first row;
- * <code>false</code> if the cursor is at any other position or the
- * result set contains no rows
+ * <code>false</code> if the cursor is at any other position or the result set
+ * contains no rows
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -887,12 +872,12 @@
}
/**
- * Retrieves whether the cursor is after the last row in
- * this <code>ResultSet</code> object.
+ * Retrieves whether the cursor is after the last row in this
+ * <code>ResultSet</code> object.
*
* @return <code>true</code> if the cursor is after the last row;
- * <code>false</code> if the cursor is at any other position or the
- * result set contains no rows
+ * <code>false</code> if the cursor is at any other position or the result set
+ * contains no rows
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -901,11 +886,11 @@
}
/**
- * Retrieves whether the cursor is on the first row of
- * this <code>ResultSet</code> object.
+ * Retrieves whether the cursor is on the first row of this
+ * <code>ResultSet</code> object.
*
* @return <code>true</code> if the cursor is on the first row;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -914,15 +899,13 @@
}
/**
- * Retrieves whether the cursor is on the last row of
- * this <code>ResultSet</code> object.
- * Note: Calling the method <code>isLast</code> may be expensive
- * because the JDBC driver
- * might need to fetch ahead one row in order to determine
- * whether the current row is the last row in the result set.
+ * Retrieves whether the cursor is on the last row of this
+ * <code>ResultSet</code> object. Note: Calling the method <code>isLast</code>
+ * may be expensive because the JDBC driver might need to fetch ahead one row in
+ * order to determine whether the current row is the last row in the result set.
*
* @return <code>true</code> if the cursor is on the last row;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -931,12 +914,12 @@
}
/**
- * Moves the cursor to the front of
- * this <code>ResultSet</code> object, just before the
- * first row. This method has no effect if the result set contains no rows.
+ * Moves the cursor to the front of this <code>ResultSet</code> object, just
+ * before the first row. This method has no effect if the result set contains no
+ * rows.
*
- * @throws java.sql.SQLException if a database access error
- * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public void beforeFirst() throws SQLException {
@@ -944,12 +927,11 @@
}
/**
- * Moves the cursor to the end of
- * this <code>ResultSet</code> object, just after the
- * last row. This method has no effect if the result set contains no rows.
+ * Moves the cursor to the end of this <code>ResultSet</code> object, just after
+ * the last row. This method has no effect if the result set contains no rows.
*
- * @throws java.sql.SQLException if a database access error
- * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public void afterLast() throws SQLException {
@@ -957,13 +939,12 @@
}
/**
- * Moves the cursor to the first row in
- * this <code>ResultSet</code> object.
+ * Moves the cursor to the first row in this <code>ResultSet</code> object.
*
- * @return <code>true</code> if the cursor is on a valid row;
- * <code>false</code> if there are no rows in the result set
- * @throws java.sql.SQLException if a database access error
- * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
+ * @return <code>true</code> if the cursor is on a valid row; <code>false</code>
+ * if there are no rows in the result set
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public boolean first() throws SQLException {
@@ -971,13 +952,12 @@
}
/**
- * Moves the cursor to the last row in
- * this <code>ResultSet</code> object.
+ * Moves the cursor to the last row in this <code>ResultSet</code> object.
*
- * @return <code>true</code> if the cursor is on a valid row;
- * <code>false</code> if there are no rows in the result set
- * @throws java.sql.SQLException if a database access error
- * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
+ * @return <code>true</code> if the cursor is on a valid row; <code>false</code>
+ * if there are no rows in the result set
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public boolean last() throws SQLException {
@@ -985,8 +965,8 @@
}
/**
- * Retrieves the current row number. The first row is number 1, the
- * second number 2, and so on.
+ * Retrieves the current row number. The first row is number 1, the second
+ * number 2, and so on.
*
* @return the current row number; <code>0</code> if there is no current row
* @throws java.sql.SQLException if a database access error occurs
@@ -997,37 +977,38 @@
}
/**
- * Moves the cursor to the given row number in
- * this <code>ResultSet</code> object.
+ * Moves the cursor to the given row number in this <code>ResultSet</code>
+ * object.
* <p/>
- * <p>If the row number is positive, the cursor moves to
- * the given row number with respect to the
- * beginning of the result set. The first row is row 1, the second
- * is row 2, and so on.
+ * <p>
+ * If the row number is positive, the cursor moves to the given row number with
+ * respect to the beginning of the result set. The first row is row 1, the
+ * second is row 2, and so on.
* <p/>
- * <p>If the given row number is negative, the cursor moves to
- * an absolute row position with respect to
- * the end of the result set. For example, calling the method
- * <code>absolute(-1)</code> positions the
- * cursor on the last row; calling the method <code>absolute(-2)</code>
- * moves the cursor to the next-to-last row, and so on.
+ * <p>
+ * If the given row number is negative, the cursor moves to an absolute row
+ * position with respect to the end of the result set. For example, calling the
+ * method <code>absolute(-1)</code> positions the cursor on the last row;
+ * calling the method <code>absolute(-2)</code> moves the cursor to the
+ * next-to-last row, and so on.
* <p/>
- * <p>An attempt to position the cursor beyond the first/last row in
- * the result set leaves the cursor before the first row or after
- * the last row.
+ * <p>
+ * An attempt to position the cursor beyond the first/last row in the result set
+ * leaves the cursor before the first row or after the last row.
* <p/>
- * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
- * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
- * is the same as calling <code>last()</code>.
+ * <p>
+ * <B>Note:</B> Calling <code>absolute(1)</code> is the same as calling
+ * <code>first()</code>. Calling <code>absolute(-1)</code> is the same as
+ * calling <code>last()</code>.
*
- * @param row the number of the row to which the cursor should move.
- * A positive number indicates the row number counting from the
- * beginning of the result set; a negative number indicates the
- * row number counting from the end of the result set
+ * @param row the number of the row to which the cursor should move. A positive
+ * number indicates the row number counting from the beginning of the result
+ * set; a negative number indicates the row number counting from the end of the
+ * result set
* @return <code>true</code> if the cursor is on the result set;
- * <code>false</code> otherwise
- * @throws java.sql.SQLException if a database access error
- * occurs, or the result set type is <code>TYPE_FORWARD_ONLY</code>
+ * <code>false</code> otherwise
+ * @throws java.sql.SQLException if a database access error occurs, or the
+ * result set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public boolean absolute(int row) throws SQLException {
@@ -1036,24 +1017,22 @@
/**
* Moves the cursor a relative number of rows, either positive or negative.
- * Attempting to move beyond the first/last row in the
- * result set positions the cursor before/after the
- * the first/last row. Calling <code>relative(0)</code> is valid, but does
- * not change the cursor position.
+ * Attempting to move beyond the first/last row in the result set positions the
+ * cursor before/after the the first/last row. Calling <code>relative(0)</code>
+ * is valid, but does not change the cursor position.
* <p/>
- * <p>Note: Calling the method <code>relative(1)</code>
- * is identical to calling the method <code>next()</code> and
- * calling the method <code>relative(-1)</code> is identical
- * to calling the method <code>previous()</code>.
+ * <p>
+ * Note: Calling the method <code>relative(1)</code> is identical to calling the
+ * method <code>next()</code> and calling the method <code>relative(-1)</code>
+ * is identical to calling the method <code>previous()</code>.
*
- * @param rows an <code>int</code> specifying the number of rows to
- * move from the current row; a positive number moves the cursor
- * forward; a negative number moves the cursor backward
- * @return <code>true</code> if the cursor is on a row;
- * <code>false</code> otherwise
- * @throws java.sql.SQLException if a database access error occurs,
- * there is no current row, or the result set type is
- * <code>TYPE_FORWARD_ONLY</code>
+ * @param rows an <code>int</code> specifying the number of rows to move from
+ * the current row; a positive number moves the cursor forward; a negative
+ * number moves the cursor backward
+ * @return <code>true</code> if the cursor is on a row; <code>false</code>
+ * otherwise
+ * @throws java.sql.SQLException if a database access error occurs, there is no
+ * current row, or the result set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public boolean relative(int rows) throws SQLException {
@@ -1061,13 +1040,12 @@
}
/**
- * Moves the cursor to the previous row in this
- * <code>ResultSet</code> object.
+ * Moves the cursor to the previous row in this <code>ResultSet</code> object.
*
- * @return <code>true</code> if the cursor is on a valid row;
- * <code>false</code> if it is off the result set
- * @throws java.sql.SQLException if a database access error
- * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
+ * @return <code>true</code> if the cursor is on a valid row; <code>false</code>
+ * if it is off the result set
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set type is <code>TYPE_FORWARD_ONLY</code>
* @since 1.2
*/
public boolean previous() throws SQLException {
@@ -1076,19 +1054,17 @@
/**
* Gives a hint as to the direction in which the rows in this
- * <code>ResultSet</code> object will be processed.
- * The initial value is determined by the
- * <code>Statement</code> object
- * that produced this <code>ResultSet</code> object.
- * The fetch direction may be changed at any time.
+ * <code>ResultSet</code> object will be processed. The initial value is
+ * determined by the <code>Statement</code> object that produced this
+ * <code>ResultSet</code> object. The fetch direction may be changed at any
+ * time.
*
- * @param direction an <code>int</code> specifying the suggested
- * fetch direction; one of <code>ResultSet.FETCH_FORWARD</code>,
- * <code>ResultSet.FETCH_REVERSE</code>, or
- * <code>ResultSet.FETCH_UNKNOWN</code>
- * @throws java.sql.SQLException if a database access error occurs or
- * the result set type is <code>TYPE_FORWARD_ONLY</code> and the fetch
- * direction is not <code>FETCH_FORWARD</code>
+ * @param direction an <code>int</code> specifying the suggested fetch
+ * direction; one of <code>ResultSet.FETCH_FORWARD</code>,
+ * <code>ResultSet.FETCH_REVERSE</code>, or <code>ResultSet.FETCH_UNKNOWN</code>
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set type is <code>TYPE_FORWARD_ONLY</code> and the fetch direction is not
+ * <code>FETCH_FORWARD</code>
* @see java.sql.Statement#setFetchDirection
* @see #getFetchDirection
* @since 1.2
@@ -1098,8 +1074,7 @@
}
/**
- * Retrieves the fetch direction for this
- * <code>ResultSet</code> object.
+ * Retrieves the fetch direction for this <code>ResultSet</code> object.
*
* @return the current fetch direction for this <code>ResultSet</code> object
* @throws java.sql.SQLException if a database access error occurs
@@ -1111,18 +1086,16 @@
}
/**
- * Gives the JDBC driver a hint as to the number of rows that should
- * be fetched from the database when more rows are needed for this
- * <code>ResultSet</code> object.
- * If the fetch size specified is zero, the JDBC driver
- * ignores the value and is free to make its own best guess as to what
- * the fetch size should be. The default value is set by the
- * <code>Statement</code> object
- * that created the result set. The fetch size may be changed at any time.
+ * Gives the JDBC driver a hint as to the number of rows that should be fetched
+ * from the database when more rows are needed for this <code>ResultSet</code>
+ * object. If the fetch size specified is zero, the JDBC driver ignores the
+ * value and is free to make its own best guess as to what the fetch size should
+ * be. The default value is set by the <code>Statement</code> object that
+ * created the result set. The fetch size may be changed at any time.
*
* @param rows the number of rows to fetch
* @throws java.sql.SQLException if a database access error occurs or the
- * condition <code>0 <= rows <= Statement.getMaxRows()</code> is not satisfied
+ * condition <code>0 <= rows <= Statement.getMaxRows()</code> is not satisfied
* @see #getFetchSize
* @since 1.2
*/
@@ -1131,8 +1104,7 @@
}
/**
- * Retrieves the fetch size for this
- * <code>ResultSet</code> object.
+ * Retrieves the fetch size for this <code>ResultSet</code> object.
*
* @return the current fetch size for this <code>ResultSet</code> object
* @throws java.sql.SQLException if a database access error occurs
@@ -1144,13 +1116,12 @@
}
/**
- * Retrieves the type of this <code>ResultSet</code> object.
- * The type is determined by the <code>Statement</code> object
- * that created the result set.
+ * Retrieves the type of this <code>ResultSet</code> object. The type is
+ * determined by the <code>Statement</code> object that created the result set.
*
* @return <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>,
- * or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1159,13 +1130,12 @@
}
/**
- * Retrieves the concurrency mode of this <code>ResultSet</code> object.
- * The concurrency used is determined by the
- * <code>Statement</code> object that created the result set.
+ * Retrieves the concurrency mode of this <code>ResultSet</code> object. The
+ * concurrency used is determined by the <code>Statement</code> object that
+ * created the result set.
*
- * @return the concurrency type, either
- * <code>ResultSet.CONCUR_READ_ONLY</code>
- * or <code>ResultSet.CONCUR_UPDATABLE</code>
+ * @return the concurrency type, either <code>ResultSet.CONCUR_READ_ONLY</code>
+ * or <code>ResultSet.CONCUR_UPDATABLE</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1174,11 +1144,11 @@
}
/**
- * Retrieves whether the current row has been updated. The value returned
+ * Retrieves whether the current row has been updated. The value returned
* depends on whether or not the result set can detect updates.
*
- * @return <code>true</code> if both (1) the row has been visibly updated
- * by the owner or another and (2) updates are detected
+ * @return <code>true</code> if both (1) the row has been visibly updated by the
+ * owner or another and (2) updates are detected
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#updatesAreDetected
* @since 1.2
@@ -1188,12 +1158,12 @@
}
/**
- * Retrieves whether the current row has had an insertion.
- * The value returned depends on whether or not this
- * <code>ResultSet</code> object can detect visible inserts.
+ * Retrieves whether the current row has had an insertion. The value returned
+ * depends on whether or not this <code>ResultSet</code> object can detect
+ * visible inserts.
*
- * @return <code>true</code> if a row has had an insertion
- * and insertions are detected; <code>false</code> otherwise
+ * @return <code>true</code> if a row has had an insertion and insertions are
+ * detected; <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#insertsAreDetected
* @since 1.2
@@ -1203,13 +1173,13 @@
}
/**
- * Retrieves whether a row has been deleted. A deleted row may leave
- * a visible "hole" in a result set. This method can be used to
- * detect holes in a result set. The value returned depends on whether
- * or not this <code>ResultSet</code> object can detect deletions.
+ * Retrieves whether a row has been deleted. A deleted row may leave a visible
+ * "hole" in a result set. This method can be used to detect holes in a result
+ * set. The value returned depends on whether or not this <code>ResultSet</code>
+ * object can detect deletions.
*
* @return <code>true</code> if a row was deleted and deletions are detected;
- * <code>false</code> otherwise
+ * <code>false</code> otherwise
* @throws java.sql.SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#deletesAreDetected
* @since 1.2
@@ -1221,10 +1191,10 @@
/**
* Gives a nullable column a null value.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code>
- * or <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @throws java.sql.SQLException if a database access error occurs
@@ -1235,14 +1205,14 @@
}
/**
- * Updates the designated column with a <code>boolean</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>boolean</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1251,14 +1221,14 @@
}
/**
- * Updates the designated column with a <code>byte</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>byte</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1267,14 +1237,14 @@
}
/**
- * Updates the designated column with a <code>short</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>short</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1283,14 +1253,14 @@
}
/**
- * Updates the designated column with an <code>int</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an <code>int</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1299,14 +1269,14 @@
}
/**
- * Updates the designated column with a <code>long</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>long</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1315,14 +1285,14 @@
}
/**
- * Updates the designated column with a <code>float</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>float</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1331,14 +1301,14 @@
}
/**
- * Updates the designated column with a <code>double</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>double</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1347,15 +1317,14 @@
}
/**
- * Updates the designated column with a <code>java.math.BigDecimal</code>
- * value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.math.BigDecimal</code> value.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1364,14 +1333,14 @@
}
/**
- * Updates the designated column with a <code>String</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>String</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1380,14 +1349,14 @@
}
/**
- * Updates the designated column with a <code>byte</code> array value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>byte</code> array value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1396,14 +1365,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Date</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Date</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1412,14 +1381,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Time</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Time</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1428,15 +1397,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Timestamp</code>
- * value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Timestamp</code> value.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1445,15 +1413,15 @@
}
/**
- * Updates the designated column with an ascii stream value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an ascii stream value. The updater methods
+ * are used to update column values in the current row or the insert row. The
+ * updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
+ * @param x the new column value
+ * @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1462,15 +1430,15 @@
}
/**
- * Updates the designated column with a binary stream value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a binary stream value. The updater methods
+ * are used to update column values in the current row or the insert row. The
+ * updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
+ * @param x the new column value
+ * @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1479,15 +1447,15 @@
}
/**
- * Updates the designated column with a character stream value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a character stream value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
+ * @param x the new column value
+ * @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1496,18 +1464,17 @@
}
/**
- * Updates the designated column with an <code>Object</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an <code>Object</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param scale for <code>java.sql.Types.DECIMA</code>
- * or <code>java.sql.Types.NUMERIC</code> types,
- * this is the number of digits after the decimal point. For all other
- * types this value will be ignored.
+ * @param x the new column value
+ * @param scale for <code>java.sql.Types.DECIMA</code> or
+ * <code>java.sql.Types.NUMERIC</code> 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
* @since 1.2
*/
@@ -1516,14 +1483,14 @@
}
/**
- * Updates the designated column with an <code>Object</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an <code>Object</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1532,11 +1499,11 @@
}
/**
- * Updates the designated column with a <code>null</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>null</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
* @throws java.sql.SQLException if a database access error occurs
@@ -1547,14 +1514,14 @@
}
/**
- * Updates the designated column with a <code>boolean</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>boolean</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1563,14 +1530,14 @@
}
/**
- * Updates the designated column with a <code>byte</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>byte</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1579,14 +1546,14 @@
}
/**
- * Updates the designated column with a <code>short</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>short</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1595,14 +1562,14 @@
}
/**
- * Updates the designated column with an <code>int</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an <code>int</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1611,14 +1578,14 @@
}
/**
- * Updates the designated column with a <code>long</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>long</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1627,14 +1594,14 @@
}
/**
- * Updates the designated column with a <code>float </code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>float </code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1643,14 +1610,14 @@
}
/**
- * Updates the designated column with a <code>double</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>double</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1659,15 +1626,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.BigDecimal</code>
- * value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.BigDecimal</code> value.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1676,14 +1642,14 @@
}
/**
- * Updates the designated column with a <code>String</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>String</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1694,13 +1660,13 @@
/**
* Updates the designated column with a byte array value.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code>
- * or <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1709,14 +1675,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Date</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Date</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1725,14 +1691,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Time</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Time</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1741,15 +1707,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Timestamp</code>
- * value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Timestamp</code> value.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1758,15 +1723,15 @@
}
/**
- * Updates the designated column with an ascii stream value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an ascii stream value. The updater methods
+ * are used to update column values in the current row or the insert row. The
+ * updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
- * @param length the length of the stream
+ * @param x the new column value
+ * @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1775,15 +1740,15 @@
}
/**
- * Updates the designated column with a binary stream value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a binary stream value. The updater methods
+ * are used to update column values in the current row or the insert row. The
+ * updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
- * @param length the length of the stream
+ * @param x the new column value
+ * @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1792,16 +1757,16 @@
}
/**
- * Updates the designated column with a character stream value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a character stream value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param reader the <code>java.io.Reader</code> object containing
- * the new column value
- * @param length the length of the stream
+ * @param reader the <code>java.io.Reader</code> object containing the new
+ * column value
+ * @param length the length of the stream
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1810,18 +1775,17 @@
}
/**
- * Updates the designated column with an <code>Object</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an <code>Object</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
- * @param scale for <code>java.sql.Types.DECIMAL</code>
- * or <code>java.sql.Types.NUMERIC</code> types,
- * this is the number of digits after the decimal point. For all other
- * types this value will be ignored.
+ * @param x the new column value
+ * @param scale for <code>java.sql.Types.DECIMAL</code> or
+ * <code>java.sql.Types.NUMERIC</code> 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
* @since 1.2
*/
@@ -1830,14 +1794,14 @@
}
/**
- * Updates the designated column with an <code>Object</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with an <code>Object</code> value. The updater
+ * methods are used to update column values in the current row or the insert
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -1846,14 +1810,13 @@
}
/**
- * Inserts the contents of the insert row into this
- * <code>ResultSet</code> object and into the database.
- * The cursor must be on the insert row when this method is called.
+ * Inserts the contents of the insert row into this <code>ResultSet</code>
+ * object and into the database. The cursor must be on the insert row when this
+ * method is called.
*
- * @throws java.sql.SQLException if a database access error occurs,
- * if this method is called when the cursor is not on the insert row,
- * or if not all of non-nullable columns in
- * the insert row have been given a value
+ * @throws java.sql.SQLException if a database access error occurs, if this
+ * method is called when the cursor is not on the insert row, or if not all of
+ * non-nullable columns in the insert row have been given a value
* @since 1.2
*/
public void insertRow() throws SQLException {
@@ -1861,12 +1824,12 @@
}
/**
- * Updates the underlying database with the new contents of the
- * current row of this <code>ResultSet</code> object.
- * This method cannot be called when the cursor is on the insert row.
+ * Updates the underlying database with the new contents of the current row of
+ * this <code>ResultSet</code> object. This method cannot be called when the
+ * cursor is on the insert row.
*
- * @throws java.sql.SQLException if a database access error occurs or
- * if this method is called when the cursor is on the insert row
+ * @throws java.sql.SQLException if a database access error occurs or if this
+ * method is called when the cursor is on the insert row
* @since 1.2
*/
public void updateRow() throws SQLException {
@@ -1874,12 +1837,12 @@
}
/**
- * Deletes the current row from this <code>ResultSet</code> object
- * and from the underlying database. This method cannot be called when
- * the cursor is on the insert row.
+ * Deletes the current row from this <code>ResultSet</code> object and from the
+ * underlying database. This method cannot be called when the cursor is on the
+ * insert row.
*
- * @throws java.sql.SQLException if a database access error occurs
- * or if this method is called when the cursor is on the insert row
+ * @throws java.sql.SQLException if a database access error occurs or if this
+ * method is called when the cursor is on the insert row
* @since 1.2
*/
public void deleteRow() throws SQLException {
@@ -1887,28 +1850,26 @@
}
/**
- * Refreshes the current row with its most recent value in
- * the database. This method cannot be called when
- * the cursor is on the insert row.
+ * Refreshes the current row with its most recent value in the database. This
+ * method cannot be called when the cursor is on the insert row.
* <p/>
- * <P>The <code>refreshRow</code> method provides a way for an
- * application to
- * explicitly tell the JDBC driver to refetch a row(s) from the
- * database. An application may want to call <code>refreshRow</code> when
- * caching or prefetching is being done by the JDBC driver to
- * fetch the latest value of a row from the database. The JDBC driver
- * may actually refresh multiple rows at once if the fetch size is
- * greater than one.
+ * <P>
+ * The <code>refreshRow</code> method provides a way for an application to
+ * explicitly tell the JDBC driver to refetch a row(s) from the database. An
+ * application may want to call <code>refreshRow</code> when caching or
+ * prefetching is being done by the JDBC driver to fetch the latest value of a
+ * row from the database. The JDBC driver may actually refresh multiple rows at
+ * once if the fetch size is greater than one.
* <p/>
- * <P> All values are refetched subject to the transaction isolation
- * level and cursor sensitivity. If <code>refreshRow</code> is called after
- * calling an updater method, but before calling
- * the method <code>updateRow</code>, then the
- * updates made to the row are lost. Calling the method
+ * <P>
+ * All values are refetched subject to the transaction isolation level and
+ * cursor sensitivity. If <code>refreshRow</code> is called after calling an
+ * updater method, but before calling the method <code>updateRow</code>, then
+ * the updates made to the row are lost. Calling the method
* <code>refreshRow</code> frequently will likely slow performance.
*
- * @throws java.sql.SQLException if a database access error
- * occurs or if this method is called when the cursor is on the insert row
+ * @throws java.sql.SQLException if a database access error occurs or if this
+ * method is called when the cursor is on the insert row
* @since 1.2
*/
public void refreshRow() throws SQLException {
@@ -1916,18 +1877,14 @@
}
/**
- * Cancels the updates made to the current row in this
- * <code>ResultSet</code> object.
- * This method may be called after calling an
- * updater method(s) and before calling
- * the method <code>updateRow</code> to roll back
- * the updates made to a row. If no updates have been made or
- * <code>updateRow</code> has already been called, this method has no
- * effect.
+ * Cancels the updates made to the current row in this <code>ResultSet</code>
+ * object. This method may be called after calling an updater method(s) and
+ * before calling the method <code>updateRow</code> to roll back the updates
+ * made to a row. If no updates have been made or <code>updateRow</code> has
+ * already been called, this method has no effect.
*
- * @throws java.sql.SQLException if a database access error
- * occurs or if this method is called when the cursor is
- * on the insert row
+ * @throws java.sql.SQLException if a database access error occurs or if this
+ * method is called when the cursor is on the insert row
* @since 1.2
*/
public void cancelRowUpdates() throws SQLException {
@@ -1935,24 +1892,21 @@
}
/**
- * Moves the cursor to the insert row. The current cursor position is
- * remembered while the cursor is positioned on the insert row.
+ * Moves the cursor to the insert row. The current cursor position is remembered
+ * while the cursor is positioned on the insert row.
* <p/>
- * The insert row is a special row associated with an updatable
- * result set. It is essentially a buffer where a new row may
- * be constructed by calling the updater methods prior to
- * inserting the row into the result set.
+ * The insert row is a special row associated with an updatable result set. It
+ * is essentially a buffer where a new row may be constructed by calling the
+ * updater methods prior to inserting the row into the result set.
* <p/>
- * Only the updater, getter,
- * and <code>insertRow</code> methods may be
- * called when the cursor is on the insert row. All of the columns in
- * a result set must be given a value each time this method is
- * called before calling <code>insertRow</code>.
- * An updater method must be called before a
- * getter method can be called on a column value.
+ * Only the updater, getter, and <code>insertRow</code> methods may be called
+ * when the cursor is on the insert row. All of the columns in a result set must
+ * be given a value each time this method is called before calling
+ * <code>insertRow</code>. An updater method must be called before a getter
+ * method can be called on a column value.
*
- * @throws java.sql.SQLException if a database access error occurs
- * or the result set is not updatable
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set is not updatable
* @since 1.2
*/
public void moveToInsertRow() throws SQLException {
@@ -1960,12 +1914,11 @@
}
/**
- * Moves the cursor to the remembered cursor position, usually the
- * current row. This method has no effect if the cursor is not on
- * the insert row.
+ * Moves the cursor to the remembered cursor position, usually the current row.
+ * This method has no effect if the cursor is not on the insert row.
*
- * @throws java.sql.SQLException if a database access error occurs
- * or the result set is not updatable
+ * @throws java.sql.SQLException if a database access error occurs or the result
+ * set is not updatable
* @since 1.2
*/
public void moveToCurrentRow() throws SQLException {
@@ -1974,14 +1927,13 @@
/**
* Retrieves the <code>Statement</code> object that produced this
- * <code>ResultSet</code> object.
- * If the result set was generated some other way, such as by a
- * <code>DatabaseMetaData</code> method, this method returns
+ * <code>ResultSet</code> object. If the result set was generated some other
+ * way, such as by a <code>DatabaseMetaData</code> method, this method returns
* <code>null</code>.
*
- * @return the <code>Statment</code> object that produced
- * this <code>ResultSet</code> object or <code>null</code>
- * if the result set was produced some other way
+ * @return the <code>Statment</code> object that produced this
+ * <code>ResultSet</code> object or <code>null</code> if the result set was
+ * produced some other way
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2000,20 +1952,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as an <code>Object</code>
- * in the Java programming language.
- * If the value is an SQL <code>NULL</code>,
- * the driver returns a Java <code>null</code>.
- * This method uses the given <code>Map</code> object
- * for the custom mapping of the
- * SQL structured or distinct type that is being retrieved.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>Object</code> in the Java
+ * programming language. If the value is an SQL <code>NULL</code>, the driver
+ * returns a Java <code>null</code>. This method uses the given <code>Map</code>
+ * object for the custom mapping of the SQL structured or distinct type that is
+ * being retrieved.
*
- * @param i the first column is 1, the second is 2, ...
- * @param map a <code>java.util.Map</code> object that contains the mapping
- * from SQL type names to classes in the Java programming language
- * @return an <code>Object</code> in the Java programming language
- * representing the SQL value
+ * @param i the first column is 1, the second is 2, ...
+ * @param map a <code>java.util.Map</code> object that contains the mapping from
+ * SQL type names to classes in the Java programming language
+ * @return an <code>Object</code> in the Java programming language representing
+ * the SQL value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2022,13 +1972,12 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>Ref</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>Ref</code> object in the Java
+ * programming language.
*
* @param i the first column is 1, the second is 2, ...
- * @return a <code>Ref</code> object representing an SQL <code>REF</code>
- * value
+ * @return a <code>Ref</code> object representing an SQL <code>REF</code> value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2037,13 +1986,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>Blob</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>Blob</code> object in the Java
+ * programming language.
*
* @param i the first column is 1, the second is 2, ...
- * @return a <code>Blob</code> object representing the SQL
- * <code>BLOB</code> value in the specified column
+ * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
+ * value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2052,13 +2001,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>Clob</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>Clob</code> object in the Java
+ * programming language.
*
* @param i the first column is 1, the second is 2, ...
- * @return a <code>Clob</code> object representing the SQL
- * <code>CLOB</code> value in the specified column
+ * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
+ * value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2067,13 +2016,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as an <code>Array</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>Array</code> object in the Java
+ * programming language.
*
* @param i the first column is 1, the second is 2, ...
- * @return an <code>Array</code> object representing the SQL
- * <code>ARRAY</code> value in the specified column
+ * @return an <code>Array</code> object representing the SQL <code>ARRAY</code>
+ * value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2082,19 +2031,17 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as an <code>Object</code>
- * in the Java programming language.
- * If the value is an SQL <code>NULL</code>,
- * the driver returns a Java <code>null</code>.
- * This method uses the specified <code>Map</code> object for
- * custom mapping if appropriate.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>Object</code> in the Java
+ * programming language. If the value is an SQL <code>NULL</code>, the driver
+ * returns a Java <code>null</code>. This method uses the specified
+ * <code>Map</code> object for custom mapping if appropriate.
*
* @param colName the name of the column from which to retrieve the value
- * @param map a <code>java.util.Map</code> object that contains the mapping
- * from SQL type names to classes in the Java programming language
- * @return an <code>Object</code> representing the SQL value in the
- * specified column
+ * @param map a <code>java.util.Map</code> object that contains the mapping from
+ * SQL type names to classes in the Java programming language
+ * @return an <code>Object</code> representing the SQL value in the specified
+ * column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2103,13 +2050,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>Ref</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>Ref</code> object in the Java
+ * programming language.
*
* @param colName the column name
- * @return a <code>Ref</code> object representing the SQL <code>REF</code>
- * value in the specified column
+ * @return a <code>Ref</code> object representing the SQL <code>REF</code> value
+ * in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2118,13 +2065,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>Blob</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>Blob</code> object in the Java
+ * programming language.
*
* @param colName the name of the column from which to retrieve the value
* @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
- * value in the specified column
+ * value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2133,13 +2080,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>Clob</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>Clob</code> object in the Java
+ * programming language.
*
* @param colName the name of the column from which to retrieve the value
* @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
- * value in the specified column
+ * value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2148,13 +2095,13 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as an <code>Array</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as an <code>Array</code> object in the Java
+ * programming language.
*
* @param colName the name of the column from which to retrieve the value
- * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> value in
- * the specified column
+ * @return an <code>Array</code> object representing the SQL <code>ARRAY</code>
+ * value in the specified column
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2163,19 +2110,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
- * in the Java programming language.
- * This method uses the given calendar to construct an appropriate millisecond
- * value for the date if the underlying database does not store
- * timezone information.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Date</code> object in the
+ * Java programming language. This method uses the given calendar to construct
+ * an appropriate millisecond value for the date if the underlying database does
+ * not store timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param cal the <code>java.util.Calendar</code> object
- * to use in constructing the date
- * @return the column value as a <code>java.sql.Date</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
+ * @param cal the <code>java.util.Calendar</code> object to use in constructing
+ * the date
+ * @return the column value as a <code>java.sql.Date</code> object; if the value
+ * is SQL <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2184,19 +2130,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.sql.Date</code> object
- * in the Java programming language.
- * This method uses the given calendar to construct an appropriate millisecond
- * value for the date if the underlying database does not store
- * timezone information.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Date</code> object in the
+ * Java programming language. This method uses the given calendar to construct
+ * an appropriate millisecond value for the date if the underlying database does
+ * not store timezone information.
*
* @param columnName the SQL name of the column from which to retrieve the value
- * @param cal the <code>java.util.Calendar</code> object
- * to use in constructing the date
- * @return the column value as a <code>java.sql.Date</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
+ * @param cal the <code>java.util.Calendar</code> object to use in constructing
+ * the date
+ * @return the column value as a <code>java.sql.Date</code> object; if the value
+ * is SQL <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2205,19 +2150,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
- * in the Java programming language.
- * This method uses the given calendar to construct an appropriate millisecond
- * value for the time if the underlying database does not store
- * timezone information.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Time</code> object in the
+ * Java programming language. This method uses the given calendar to construct
+ * an appropriate millisecond value for the time if the underlying database does
+ * not store timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param cal the <code>java.util.Calendar</code> object
- * to use in constructing the time
- * @return the column value as a <code>java.sql.Time</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
+ * @param cal the <code>java.util.Calendar</code> object to use in constructing
+ * the time
+ * @return the column value as a <code>java.sql.Time</code> object; if the value
+ * is SQL <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2226,19 +2170,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.sql.Time</code> object
- * in the Java programming language.
- * This method uses the given calendar to construct an appropriate millisecond
- * value for the time if the underlying database does not store
- * timezone information.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Time</code> object in the
+ * Java programming language. This method uses the given calendar to construct
+ * an appropriate millisecond value for the time if the underlying database does
+ * not store timezone information.
*
* @param columnName the SQL name of the column
- * @param cal the <code>java.util.Calendar</code> object
- * to use in constructing the time
- * @return the column value as a <code>java.sql.Time</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
+ * @param cal the <code>java.util.Calendar</code> object to use in constructing
+ * the time
+ * @return the column value as a <code>java.sql.Time</code> object; if the value
+ * is SQL <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2247,19 +2190,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
- * in the Java programming language.
- * This method uses the given calendar to construct an appropriate millisecond
- * value for the timestamp if the underlying database does not store
- * timezone information.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object in
+ * the Java programming language. This method uses the given calendar to
+ * construct an appropriate millisecond value for the timestamp if the
+ * underlying database does not store timezone information.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param cal the <code>java.util.Calendar</code> object
- * to use in constructing the timestamp
- * @return the column value as a <code>java.sql.Timestamp</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
+ * @param cal the <code>java.util.Calendar</code> object to use in constructing
+ * the timestamp
+ * @return the column value as a <code>java.sql.Timestamp</code> object; if the
+ * value is SQL <code>NULL</code>, the value returned is <code>null</code> in
+ * the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2268,19 +2210,18 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object
- * in the Java programming language.
- * This method uses the given calendar to construct an appropriate millisecond
- * value for the timestamp if the underlying database does not store
- * timezone information.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.sql.Timestamp</code> object in
+ * the Java programming language. This method uses the given calendar to
+ * construct an appropriate millisecond value for the timestamp if the
+ * underlying database does not store timezone information.
*
* @param columnName the SQL name of the column
- * @param cal the <code>java.util.Calendar</code> object
- * to use in constructing the date
- * @return the column value as a <code>java.sql.Timestamp</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
+ * @param cal the <code>java.util.Calendar</code> object to use in constructing
+ * the date
+ * @return the column value as a <code>java.sql.Timestamp</code> object; if the
+ * value is SQL <code>NULL</code>, the value returned is <code>null</code> in
+ * the Java programming language
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -2289,16 +2230,17 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
- * object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.net.URL</code> object in the
+ * Java programming language.
*
- * @param columnIndex the index of the column 1 is the first, 2 is the second,...
- * @return the column value as a <code>java.net.URL</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
- * @throws java.sql.SQLException if a database access error occurs,
- * or if a URL is malformed
+ * @param columnIndex the index of the column 1 is the first, 2 is the
+ * second,...
+ * @return the column value as a <code>java.net.URL</code> object; if the value
+ * is SQL <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language
+ * @throws java.sql.SQLException if a database access error occurs, or if a URL
+ * is malformed
* @since 1.4
*/
public URL getURL(int columnIndex) throws SQLException {
@@ -2306,16 +2248,16 @@
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>java.net.URL</code>
- * object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.net.URL</code> object in the
+ * Java programming language.
*
* @param columnName the SQL name of the column
- * @return the column value as a <code>java.net.URL</code> object;
- * if the value is SQL <code>NULL</code>,
- * the value returned is <code>null</code> in the Java programming language
- * @throws java.sql.SQLException if a database access error occurs
- * or if a URL is malformed
+ * @return the column value as a <code>java.net.URL</code> object; if the value
+ * is SQL <code>NULL</code>, the value returned is <code>null</code> in the Java
+ * programming language
+ * @throws java.sql.SQLException if a database access error occurs or if a URL
+ * is malformed
* @since 1.4
*/
public URL getURL(String columnName) throws SQLException {
@@ -2323,14 +2265,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Ref</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Ref</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2339,14 +2281,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Ref</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Ref</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2355,14 +2297,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Blob</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Blob</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2371,14 +2313,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Blob</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Blob</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2387,14 +2329,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Clob</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Clob</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2403,14 +2345,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Clob</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Clob</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2419,14 +2361,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Array</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Array</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -2435,14 +2377,14 @@
}
/**
- * Updates the designated column with a <code>java.sql.Array</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.Array</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnName the name of the column
- * @param x the new column value
+ * @param x the new column value
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/StatementWrapper.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/StatementWrapper.java
index f53091a..9a6ce0d 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/StatementWrapper.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/StatementWrapper.java
@@ -16,11 +16,6 @@
package com.sun.gjc.spi.base;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.util.MethodExecutor;
-import com.sun.gjc.util.StatementLeakDetector;
-import com.sun.gjc.util.StatementLeakListener;
-import com.sun.logging.LogDomains;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
@@ -30,6 +25,13 @@
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
+
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.util.MethodExecutor;
+import com.sun.gjc.util.StatementLeakDetector;
+import com.sun.gjc.util.StatementLeakListener;
+import com.sun.logging.LogDomains;
+
import jakarta.resource.ResourceException;
/**
@@ -37,101 +39,93 @@
*/
public abstract class StatementWrapper implements Statement, StatementLeakListener {
- protected Connection connection = null;
- protected Statement jdbcStatement = null;
- protected StatementLeakDetector leakDetector = null;
- private boolean markedForReclaim = false;
- protected final static Logger _logger;
- protected MethodExecutor executor = null;
- private boolean closeOnCompletion = false;
+ protected final static Logger _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
+
+ protected Connection connection;
+ protected Statement jdbcStatement;
+ protected StatementLeakDetector leakDetector;
+ private boolean markedForReclaim;
+ protected MethodExecutor executor;
+ private boolean closeOnCompletion;
protected AtomicInteger resultSetCount = new AtomicInteger();
- static {
- _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- }
-
/**
* Abstract class for wrapping Statement<br>
*
- * @param con ConnectionWrapper <br>
+ * @param con ConnectionWrapper <br>
* @param statement Statement that is to be wrapped<br>
*/
public StatementWrapper(Connection con, Statement statement) {
connection = con;
jdbcStatement = statement;
executor = new MethodExecutor();
- //Start leak tracing if statement is a pure Statement & stmtWrapping is ON
- //Check if this is an instanceof PS/CS. There could exist
- //a CustomStatement class in a jdbc driver that implements PS/CS as well
- //as Statement
- if(!(this instanceof PreparedStatement) &&
- !(this instanceof CallableStatement)) {
+
+ // Start leak tracing if statement is a pure Statement & stmtWrapping is ON
+ // Check if this is an instanceof PS/CS. There could exist
+ // a CustomStatement class in a jdbc driver that implements PS/CS as well
+ // as Statement
+ if (!(this instanceof PreparedStatement) && !(this instanceof CallableStatement)) {
ConnectionHolder wrappedCon = (ConnectionHolder) con;
leakDetector = wrappedCon.getManagedConnection().getLeakDetector();
- if(leakDetector != null) {
+ if (leakDetector != null) {
leakDetector.startStatementLeakTracing(jdbcStatement, this);
}
}
- //If PS or CS, do not start leak tracing here
+ // If PS or CS, do not start leak tracing here
}
/**
* Executes the given SQL statement, which may be an <code>INSERT</code>,
- * <code>UPDATE</code>, or <code>DELETE</code> statement or an
- * SQL statement that returns nothing, such as an SQL DDL statement.
+ * <code>UPDATE</code>, or <code>DELETE</code> statement or an SQL statement
+ * that returns nothing, such as an SQL DDL statement.
*
* @param sql an SQL <code>INSERT</code>, <code>UPDATE</code> or
- * <code>DELETE</code> statement or an SQL statement that returns nothing
- * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>
- * or <code>DELETE</code> statements, or <code>0</code> for SQL statements
- * that return nothing
+ * <code>DELETE</code> statement or an SQL statement that returns nothing
+ * @return either the row count for <code>INSERT</code>, <code>UPDATE</code> or
+ * <code>DELETE</code> statements, or <code>0</code> for SQL statements that
+ * return nothing
* @throws java.sql.SQLException if a database access error occurs or the given
- * SQL statement produces a <code>ResultSet</code> object
+ * SQL statement produces a <code>ResultSet</code> object
*/
public int executeUpdate(final String sql) throws SQLException {
return jdbcStatement.executeUpdate(sql);
}
/**
- * Releases this <code>Statement</code> object's database
- * and JDBC resources immediately instead of waiting for
- * this to happen when it is automatically closed.
- * It is generally good practice to release resources as soon as
- * you are finished with them to avoid tying up database
- * resources.
+ * Releases this <code>Statement</code> object's database and JDBC resources
+ * immediately instead of waiting for this to happen when it is automatically
+ * closed. It is generally good practice to release resources as soon as you are
+ * finished with them to avoid tying up database resources.
* <p/>
- * Calling the method <code>close</code> on a <code>Statement</code>
- * object that is already closed has no effect.
+ * Calling the method <code>close</code> on a <code>Statement</code> object that
+ * is already closed has no effect.
* <p/>
- * <B>Note:</B> A <code>Statement</code> object is automatically closed
- * when it is garbage collected. When a <code>Statement</code> object is
- * closed, its current <code>ResultSet</code> object, if one exists, is
- * also closed.
+ * <B>Note:</B> A <code>Statement</code> object is automatically closed when it
+ * is garbage collected. When a <code>Statement</code> object is closed, its
+ * current <code>ResultSet</code> object, if one exists, is also closed.
*
* @throws java.sql.SQLException if a database access error occurs
*/
public void close() throws SQLException {
- //Stop leak tracing
- if(leakDetector != null) {
+ // Stop leak tracing
+ if (leakDetector != null) {
leakDetector.stopStatementLeakTracing(jdbcStatement, this);
}
jdbcStatement.close();
}
/**
- * Retrieves the maximum number of bytes that can be
- * returned for character and binary column values in a <code>ResultSet</code>
- * object produced by this <code>Statement</code> object.
- * This limit applies only to <code>BINARY</code>,
- * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>,
- * <code>VARCHAR</code>, and <code>LONGVARCHAR</code>
- * columns. If the limit is exceeded, the excess data is silently
- * discarded.
+ * Retrieves the maximum number of bytes that can be returned for character and
+ * binary column values in a <code>ResultSet</code> object produced by this
+ * <code>Statement</code> object. This limit applies only to
+ * <code>BINARY</code>, <code>VARBINARY</code>, <code>LONGVARBINARY</code>,
+ * <code>CHAR</code>, <code>VARCHAR</code>, and <code>LONGVARCHAR</code>
+ * columns. If the limit is exceeded, the excess data is silently discarded.
*
* @return the current column size limit for columns storing character and
- * binary values; zero means there is no limit
+ * binary values; zero means there is no limit
* @throws java.sql.SQLException if a database access error occurs
* @see #setMaxFieldSize
*/
@@ -141,17 +135,15 @@
/**
* Sets the limit for the maximum number of bytes in a <code>ResultSet</code>
- * column storing character or binary values to
- * the given number of bytes. This limit applies
- * only to <code>BINARY</code>, <code>VARBINARY</code>,
+ * column storing character or binary values to the given number of bytes. This
+ * limit applies only to <code>BINARY</code>, <code>VARBINARY</code>,
* <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>, and
- * <code>LONGVARCHAR</code> fields. If the limit is exceeded, the excess data
- * is silently discarded. For maximum portability, use values
- * greater than 256.
+ * <code>LONGVARCHAR</code> fields. If the limit is exceeded, the excess data is
+ * silently discarded. For maximum portability, use values greater than 256.
*
* @param max the new column size limit in bytes; zero means there is no limit
- * @throws java.sql.SQLException if a database access error occurs
- * or the condition max >= 0 is not satisfied
+ * @throws java.sql.SQLException if a database access error occurs or the
+ * condition max >= 0 is not satisfied
* @see #getMaxFieldSize
*/
public void setMaxFieldSize(int max) throws SQLException {
@@ -159,14 +151,13 @@
}
/**
- * Retrieves the maximum number of rows that a
- * <code>ResultSet</code> object produced by this
- * <code>Statement</code> object can contain. If this limit is exceeded,
- * the excess rows are silently dropped.
+ * Retrieves the maximum number of rows that a <code>ResultSet</code> object
+ * produced by this <code>Statement</code> object can contain. If this limit is
+ * exceeded, the excess rows are silently dropped.
*
* @return the current maximum number of rows for a <code>ResultSet</code>
- * object produced by this <code>Statement</code> object;
- * zero means there is no limit
+ * object produced by this <code>Statement</code> object; zero means there is no
+ * limit
* @throws java.sql.SQLException if a database access error occurs
* @see #setMaxRows
*/
@@ -175,14 +166,13 @@
}
/**
- * Sets the limit for the maximum number of rows that any
- * <code>ResultSet</code> object can contain to the given number.
- * If the limit is exceeded, the excess
+ * Sets the limit for the maximum number of rows that any <code>ResultSet</code>
+ * object can contain to the given number. If the limit is exceeded, the excess
* rows are silently dropped.
*
* @param max the new max rows limit; zero means there is no limit
- * @throws java.sql.SQLException if a database access error occurs
- * or the condition max >= 0 is not satisfied
+ * @throws java.sql.SQLException if a database access error occurs or the
+ * condition max >= 0 is not satisfied
* @see #getMaxRows
*/
public void setMaxRows(int max) throws SQLException {
@@ -190,16 +180,16 @@
}
/**
- * Sets escape processing on or off.
- * If escape scanning is on (the default), the driver will do
- * escape substitution before sending the SQL statement to the database.
+ * Sets escape processing on or off. If escape scanning is on (the default), the
+ * driver will do escape substitution before sending the SQL statement to the
+ * database.
* <p/>
- * Note: Since prepared statements have usually been parsed prior
- * to making this call, disabling escape processing for
- * <code>PreparedStatements</code> objects will have no effect.
+ * Note: Since prepared statements have usually been parsed prior to making this
+ * call, disabling escape processing for <code>PreparedStatements</code> objects
+ * will have no effect.
*
* @param enable <code>true</code> to enable escape processing;
- * <code>false</code> to disable it
+ * <code>false</code> to disable it
* @throws java.sql.SQLException if a database access error occurs
*/
public void setEscapeProcessing(boolean enable) throws SQLException {
@@ -207,12 +197,12 @@
}
/**
- * Retrieves the number of seconds the driver will
- * wait for a <code>Statement</code> object to execute. If the limit is exceeded, a
+ * Retrieves the number of seconds the driver will wait for a
+ * <code>Statement</code> object to execute. If the limit is exceeded, a
* <code>SQLException</code> is thrown.
*
- * @return the current query timeout limit in seconds; zero means there is
- * no limit
+ * @return the current query timeout limit in seconds; zero means there is no
+ * limit
* @throws java.sql.SQLException if a database access error occurs
* @see #setQueryTimeout
*/
@@ -221,14 +211,14 @@
}
/**
- * Sets the number of seconds the driver will wait for a
- * <code>Statement</code> object to execute to the given number of seconds.
- * If the limit is exceeded, an <code>SQLException</code> is thrown.
+ * Sets the number of seconds the driver will wait for a <code>Statement</code>
+ * object to execute to the given number of seconds. If the limit is exceeded,
+ * an <code>SQLException</code> is thrown.
*
- * @param seconds the new query timeout limit in seconds; zero means
- * there is no limit
- * @throws java.sql.SQLException if a database access error occurs
- * or the condition seconds >= 0 is not satisfied
+ * @param seconds the new query timeout limit in seconds; zero means there is no
+ * limit
+ * @throws java.sql.SQLException if a database access error occurs or the
+ * condition seconds >= 0 is not satisfied
* @see #getQueryTimeout
*/
public void setQueryTimeout(int seconds) throws SQLException {
@@ -236,10 +226,9 @@
}
/**
- * Cancels this <code>Statement</code> object if both the DBMS and
- * driver support aborting an SQL statement.
- * This method can be used by one thread to cancel a statement that
- * is being executed by another thread.
+ * Cancels this <code>Statement</code> object if both the DBMS and driver
+ * support aborting an SQL statement. This method can be used by one thread to
+ * cancel a statement that is being executed by another thread.
*
* @throws java.sql.SQLException if a database access error occurs
*/
@@ -248,33 +237,34 @@
}
/**
- * Retrieves the first warning reported by calls on this <code>Statement</code> object.
- * Subsequent <code>Statement</code> object warnings will be chained to this
- * <code>SQLWarning</code> object.
+ * Retrieves the first warning reported by calls on this <code>Statement</code>
+ * object. Subsequent <code>Statement</code> object warnings will be chained to
+ * this <code>SQLWarning</code> object.
* <p/>
- * <p>The warning chain is automatically cleared each time
- * a statement is (re)executed. This method may not be called on a closed
- * <code>Statement</code> object; doing so will cause an <code>SQLException</code>
- * to be thrown.
+ * <p>
+ * The warning chain is automatically cleared each time a statement is
+ * (re)executed. This method may not be called on a closed
+ * <code>Statement</code> object; doing so will cause an
+ * <code>SQLException</code> to be thrown.
* <p/>
- * <P><B>Note:</B> If you are processing a <code>ResultSet</code> object, any
- * warnings associated with reads on that <code>ResultSet</code> object
- * will be chained on it rather than on the <code>Statement</code>
- * object that produced it.
+ * <P>
+ * <B>Note:</B> If you are processing a <code>ResultSet</code> object, any
+ * warnings associated with reads on that <code>ResultSet</code> object will be
+ * chained on it rather than on the <code>Statement</code> object that produced
+ * it.
*
- * @return the first <code>SQLWarning</code> object or <code>null</code>
- * if there are no warnings
+ * @return the first <code>SQLWarning</code> object or <code>null</code> if
+ * there are no warnings
* @throws java.sql.SQLException if a database access error occurs or this
- * method is called on a closed statement
+ * method is called on a closed statement
*/
public SQLWarning getWarnings() throws SQLException {
return jdbcStatement.getWarnings();
}
/**
- * Clears all the warnings reported on this <code>Statement</code>
- * object. After a call to this method,
- * the method <code>getWarnings</code> will return
+ * Clears all the warnings reported on this <code>Statement</code> object. After
+ * a call to this method, the method <code>getWarnings</code> will return
* <code>null</code> until a new warning is reported for this
* <code>Statement</code> object.
*
@@ -285,24 +275,23 @@
}
/**
- * Sets the SQL cursor name to the given <code>String</code>, which
- * will be used by subsequent <code>Statement</code> object
- * <code>execute</code> methods. This name can then be
- * used in SQL positioned update or delete statements to identify the
- * current row in the <code>ResultSet</code> object generated by this
- * statement. If the database does not support positioned update/delete,
- * this method is a noop. To insure that a cursor has the proper isolation
- * level to support updates, the cursor's <code>SELECT</code> statement
- * should have the form <code>SELECT FOR UPDATE</code>. If
- * <code>FOR UPDATE</code> is not present, positioned updates may fail.
+ * Sets the SQL cursor name to the given <code>String</code>, which will be used
+ * by subsequent <code>Statement</code> object <code>execute</code> methods.
+ * This name can then be used in SQL positioned update or delete statements to
+ * identify the current row in the <code>ResultSet</code> object generated by
+ * this statement. If the database does not support positioned update/delete,
+ * this method is a noop. To insure that a cursor has the proper isolation level
+ * to support updates, the cursor's <code>SELECT</code> statement should have
+ * the form <code>SELECT FOR UPDATE</code>. If <code>FOR UPDATE</code> is not
+ * present, positioned updates may fail.
* <p/>
- * <P><B>Note:</B> By definition, the execution of positioned updates and
- * deletes must be done by a different <code>Statement</code> object than
- * the one that generated the <code>ResultSet</code> object being used for
- * positioning. Also, cursor names must be unique within a connection.
+ * <P>
+ * <B>Note:</B> By definition, the execution of positioned updates and deletes
+ * must be done by a different <code>Statement</code> object than the one that
+ * generated the <code>ResultSet</code> object being used for positioning. Also,
+ * cursor names must be unique within a connection.
*
- * @param name the new cursor name, which must be unique within
- * a connection
+ * @param name the new cursor name, which must be unique within a connection
* @throws java.sql.SQLException if a database access error occurs
*/
public void setCursorName(String name) throws SQLException {
@@ -310,23 +299,20 @@
}
/**
- * Executes the given SQL statement, which may return multiple results.
- * In some (uncommon) situations, a single SQL statement may return
- * multiple result sets and/or update counts. Normally you can ignore
- * this unless you are (1) executing a stored procedure that you know may
- * return multiple results or (2) you are dynamically executing an
- * unknown SQL string.
+ * Executes the given SQL statement, which may return multiple results. In some
+ * (uncommon) situations, a single SQL statement may return multiple result sets
+ * and/or update counts. Normally you can ignore this unless you are (1)
+ * executing a stored procedure that you know may return multiple results or (2)
+ * you are dynamically executing an unknown SQL string.
* <p/>
* The <code>execute</code> method executes an SQL statement and indicates the
- * form of the first result. You must then use the methods
- * <code>getResultSet</code> or <code>getUpdateCount</code>
- * to retrieve the result, and <code>getMoreResults</code> to
- * move to any subsequent result(s).
+ * form of the first result. You must then use the methods
+ * <code>getResultSet</code> or <code>getUpdateCount</code> to retrieve the
+ * result, and <code>getMoreResults</code> to move to any subsequent result(s).
*
* @param sql any SQL statement
* @return <code>true</code> if the first result is a <code>ResultSet</code>
- * object; <code>false</code> if it is an update count or there are
- * no results
+ * object; <code>false</code> if it is an update count or there are no results
* @throws java.sql.SQLException if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
@@ -336,14 +322,13 @@
return jdbcStatement.execute(sql);
}
-
/**
- * Retrieves the current result as an update count;
- * if the result is a <code>ResultSet</code> object or there are no more results, -1
- * is returned. This method should be called only once per result.
+ * Retrieves the current result as an update count; if the result is a
+ * <code>ResultSet</code> object or there are no more results, -1 is returned.
+ * This method should be called only once per result.
*
* @return the current result as an update count; -1 if the current result is a
- * <code>ResultSet</code> object or there are no more results
+ * <code>ResultSet</code> object or there are no more results
* @throws java.sql.SQLException if a database access error occurs
* @see #execute
*/
@@ -353,19 +338,21 @@
/**
* Moves to this <code>Statement</code> object's next result, returns
- * <code>true</code> if it is a <code>ResultSet</code> object, and
- * implicitly closes any current <code>ResultSet</code>
- * object(s) obtained with the method <code>getResultSet</code>.
+ * <code>true</code> if it is a <code>ResultSet</code> object, and implicitly
+ * closes any current <code>ResultSet</code> object(s) obtained with the method
+ * <code>getResultSet</code>.
* <p/>
- * <P>There are no more results when the following is true:
+ * <P>
+ * There are no more results when the following is true:
+ *
* <PRE>
* // stmt is a Statement object
* ((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))
* </PRE>
*
* @return <code>true</code> if the next result is a <code>ResultSet</code>
- * object; <code>false</code> if it is an update count or there are
- * no more results
+ * object; <code>false</code> if it is an update count or there are no more
+ * results
* @throws java.sql.SQLException if a database access error occurs
* @see #execute
*/
@@ -374,21 +361,18 @@
}
/**
- * Gives the driver a hint as to the direction in which
- * rows will be processed in <code>ResultSet</code>
- * objects created using this <code>Statement</code> object. The
- * default value is <code>ResultSet.FETCH_FORWARD</code>.
+ * Gives the driver a hint as to the direction in which rows will be processed
+ * in <code>ResultSet</code> objects created using this <code>Statement</code>
+ * object. The default value is <code>ResultSet.FETCH_FORWARD</code>.
* <p/>
- * Note that this method sets the default fetch direction for
- * result sets generated by this <code>Statement</code> object.
- * Each result set has its own methods for getting and setting
- * its own fetch direction.
+ * Note that this method sets the default fetch direction for result sets
+ * generated by this <code>Statement</code> object. Each result set has its own
+ * methods for getting and setting its own fetch direction.
*
* @param direction the initial direction for processing rows
- * @throws java.sql.SQLException if a database access error occurs
- * or the given direction
- * is not one of <code>ResultSet.FETCH_FORWARD</code>,
- * <code>ResultSet.FETCH_REVERSE</code>, or <code>ResultSet.FETCH_UNKNOWN</code>
+ * @throws java.sql.SQLException if a database access error occurs or the given
+ * direction is not one of <code>ResultSet.FETCH_FORWARD</code>,
+ * <code>ResultSet.FETCH_REVERSE</code>, or <code>ResultSet.FETCH_UNKNOWN</code>
* @see #getFetchDirection
* @since 1.2
*/
@@ -397,15 +381,14 @@
}
/**
- * Retrieves the direction for fetching rows from
- * database tables that is the default for result sets
- * generated from this <code>Statement</code> object.
- * If this <code>Statement</code> object has not set
- * a fetch direction by calling the method <code>setFetchDirection</code>,
- * the return value is implementation-specific.
+ * Retrieves the direction for fetching rows from database tables that is the
+ * default for result sets generated from this <code>Statement</code> object. If
+ * this <code>Statement</code> object has not set a fetch direction by calling
+ * the method <code>setFetchDirection</code>, the return value is
+ * implementation-specific.
*
- * @return the default fetch direction for result sets generated
- * from this <code>Statement</code> object
+ * @return the default fetch direction for result sets generated from this
+ * <code>Statement</code> object
* @throws java.sql.SQLException if a database access error occurs
* @see #setFetchDirection
* @since 1.2
@@ -415,16 +398,15 @@
}
/**
- * Gives the JDBC driver a hint as to the number of rows that should
- * be fetched from the database when more rows are needed. The number
- * of rows specified affects only result sets created using this
- * statement. If the value specified is zero, then the hint is ignored.
- * The default value is zero.
+ * Gives the JDBC driver a hint as to the number of rows that should be fetched
+ * from the database when more rows are needed. The number of rows specified
+ * affects only result sets created using this statement. If the value specified
+ * is zero, then the hint is ignored. The default value is zero.
*
* @param rows the number of rows to fetch
* @throws java.sql.SQLException if a database access error occurs, or the
- * condition 0 <= <code>rows</code> <= <code>this.getMaxRows()</code>
- * is not satisfied.
+ * condition 0 <= <code>rows</code> <= <code>this.getMaxRows()</code> is not
+ * satisfied.
* @see #getFetchSize
* @since 1.2
*/
@@ -433,15 +415,14 @@
}
/**
- * Retrieves the number of result set rows that is the default
- * fetch size for <code>ResultSet</code> objects
- * generated from this <code>Statement</code> object.
- * If this <code>Statement</code> object has not set
- * a fetch size by calling the method <code>setFetchSize</code>,
- * the return value is implementation-specific.
+ * Retrieves the number of result set rows that is the default fetch size for
+ * <code>ResultSet</code> objects generated from this <code>Statement</code>
+ * object. If this <code>Statement</code> object has not set a fetch size by
+ * calling the method <code>setFetchSize</code>, the return value is
+ * implementation-specific.
*
- * @return the default fetch size for result sets generated
- * from this <code>Statement</code> object
+ * @return the default fetch size for result sets generated from this
+ * <code>Statement</code> object
* @throws java.sql.SQLException if a database access error occurs
* @see #setFetchSize
* @since 1.2
@@ -455,7 +436,7 @@
* generated by this <code>Statement</code> object.
*
* @return either <code>ResultSet.CONCUR_READ_ONLY</code> or
- * <code>ResultSet.CONCUR_UPDATABLE</code>
+ * <code>ResultSet.CONCUR_UPDATABLE</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -464,12 +445,12 @@
}
/**
- * Retrieves the result set type for <code>ResultSet</code> objects
- * generated by this <code>Statement</code> object.
+ * Retrieves the result set type for <code>ResultSet</code> objects generated by
+ * this <code>Statement</code> object.
*
* @return one of <code>ResultSet.TYPE_FORWARD_ONLY</code>,
- * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
- * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
+ * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.2
*/
@@ -479,15 +460,15 @@
/**
* Adds the given SQL command to the current list of commmands for this
- * <code>Statement</code> object. The commands in this list can be
- * executed as a batch by calling the method <code>executeBatch</code>.
+ * <code>Statement</code> object. The commands in this list can be executed as a
+ * batch by calling the method <code>executeBatch</code>.
* <p/>
- * <B>NOTE:</B> This method is optional.
+ * <B>NOTE:</B> This method is optional.
*
* @param sql typically this is a static SQL <code>INSERT</code> or
- * <code>UPDATE</code> statement
+ * <code>UPDATE</code> statement
* @throws java.sql.SQLException if a database access error occurs, or the
- * driver does not support batch updates
+ * driver does not support batch updates
* @see #executeBatch
* @since 1.2
*/
@@ -496,13 +477,12 @@
}
/**
- * Empties this <code>Statement</code> object's current list of
- * SQL commands.
+ * Empties this <code>Statement</code> object's current list of SQL commands.
* <p/>
- * <B>NOTE:</B> This method is optional.
+ * <B>NOTE:</B> This method is optional.
*
- * @throws java.sql.SQLException if a database access error occurs or the
- * driver does not support batch updates
+ * @throws java.sql.SQLException if a database access error occurs or the driver
+ * does not support batch updates
* @see #addBatch
* @since 1.2
*/
@@ -511,51 +491,48 @@
}
/**
- * Submits a batch of commands to the database for execution and
- * if all commands execute successfully, returns an array of update counts.
- * The <code>int</code> elements of the array that is returned are ordered
- * to correspond to the commands in the batch, which are ordered
- * according to the order in which they were added to the batch.
- * The elements in the array returned by the method <code>executeBatch</code>
- * may be one of the following:
+ * Submits a batch of commands to the database for execution and if all commands
+ * execute successfully, returns an array of update counts. The <code>int</code>
+ * elements of the array that is returned are ordered to correspond to the
+ * commands in the batch, which are ordered according to the order in which they
+ * were added to the batch. The elements in the array returned by the method
+ * <code>executeBatch</code> may be one of the following:
* <OL>
- * <LI>A number greater than or equal to zero -- indicates that the
- * command was processed successfully and is an update count giving the
- * number of rows in the database that were affected by the command's
- * execution
+ * <LI>A number greater than or equal to zero -- indicates that the command was
+ * processed successfully and is an update count giving the number of rows in
+ * the database that were affected by the command's execution
* <LI>A value of <code>SUCCESS_NO_INFO</code> -- indicates that the command was
- * processed successfully but that the number of rows affected is
- * unknown
+ * processed successfully but that the number of rows affected is unknown
* <p/>
- * If one of the commands in a batch update fails to execute properly,
- * this method throws a <code>BatchUpdateException</code>, and a JDBC
- * driver may or may not continue to process the remaining commands in
- * the batch. However, the driver's behavior must be consistent with a
- * particular DBMS, either always continuing to process commands or never
- * continuing to process commands. If the driver continues processing
- * after a failure, the array returned by the method
- * <code>BatchUpdateException.getUpdateCounts</code>
- * will contain as many elements as there are commands in the batch, and
- * at least one of the elements will be the following:
+ * If one of the commands in a batch update fails to execute properly, this
+ * method throws a <code>BatchUpdateException</code>, and a JDBC driver may or
+ * may not continue to process the remaining commands in the batch. However, the
+ * driver's behavior must be consistent with a particular DBMS, either always
+ * continuing to process commands or never continuing to process commands. If
+ * the driver continues processing after a failure, the array returned by the
+ * method <code>BatchUpdateException.getUpdateCounts</code> will contain as many
+ * elements as there are commands in the batch, and at least one of the elements
+ * will be the following:
* <p/>
- * <LI>A value of <code>EXECUTE_FAILED</code> -- indicates that the command failed
- * to execute successfully and occurs only if a driver continues to
+ * <LI>A value of <code>EXECUTE_FAILED</code> -- indicates that the command
+ * failed to execute successfully and occurs only if a driver continues to
* process commands after a command fails
* </OL>
* <p/>
- * A driver is not required to implement this method.
- * The possible implementations and return values have been modified in
- * the Java 2 SDK, Standard Edition, version 1.3 to
- * accommodate the option of continuing to proccess commands in a batch
- * update after a <code>BatchUpdateException</code> obejct has been thrown.
+ * A driver is not required to implement this method. The possible
+ * implementations and return values have been modified in the Java 2 SDK,
+ * Standard Edition, version 1.3 to accommodate the option of continuing to
+ * proccess commands in a batch update after a <code>BatchUpdateException</code>
+ * obejct has been thrown.
*
- * @return an array of update counts containing one element for each
- * command in the batch. The elements of the array are ordered according
- * to the order in which commands were added to the batch.
- * @throws java.sql.SQLException if a database access error occurs or the
- * driver does not support batch statements. Throws {@link java.sql.BatchUpdateException}
- * (a subclass of <code>SQLException</code>) if one of the commands sent to the
- * database fails to execute properly or attempts to return a result set.
+ * @return an array of update counts containing one element for each command in
+ * the batch. The elements of the array are ordered according to the order in
+ * which commands were added to the batch.
+ * @throws java.sql.SQLException if a database access error occurs or the driver
+ * does not support batch statements. Throws
+ * {@link java.sql.BatchUpdateException} (a subclass of
+ * <code>SQLException</code>) if one of the commands sent to the database fails
+ * to execute properly or attempts to return a result set.
* @since 1.3
*/
public int[] executeBatch() throws SQLException {
@@ -563,8 +540,8 @@
}
/**
- * Retrieves the <code>Connection</code> object
- * that produced this <code>Statement</code> object.
+ * Retrieves the <code>Connection</code> object that produced this
+ * <code>Statement</code> object.
*
* @return the connection that produced this statement
* @throws java.sql.SQLException if a database access error occurs
@@ -585,32 +562,33 @@
}
/**
- * Moves to this <code>Statement</code> object's next result, deals with
- * any current <code>ResultSet</code> object(s) according to the instructions
- * specified by the given flag, and returns
- * <code>true</code> if the next result is a <code>ResultSet</code> object.
+ * Moves to this <code>Statement</code> object's next result, deals with any
+ * current <code>ResultSet</code> object(s) according to the instructions
+ * specified by the given flag, and returns <code>true</code> if the next result
+ * is a <code>ResultSet</code> object.
* <p/>
- * <P>There are no more results when the following is true:
+ * <P>
+ * There are no more results when the following is true:
+ *
* <PRE>
* // stmt is a Statement object
* ((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))
* </PRE>
*
- * @param current one of the following <code>Statement</code>
- * constants indicating what should happen to current
- * <code>ResultSet</code> objects obtained using the method
- * <code>getResultSet</code>:
- * <code>Statement.CLOSE_CURRENT_RESULT</code>,
- * <code>Statement.KEEP_CURRENT_RESULT</code>, or
- * <code>Statement.CLOSE_ALL_RESULTS</code>
+ * @param current one of the following <code>Statement</code> constants
+ * indicating what should happen to current <code>ResultSet</code> objects
+ * obtained using the method <code>getResultSet</code>:
+ * <code>Statement.CLOSE_CURRENT_RESULT</code>,
+ * <code>Statement.KEEP_CURRENT_RESULT</code>, or
+ * <code>Statement.CLOSE_ALL_RESULTS</code>
* @return <code>true</code> if the next result is a <code>ResultSet</code>
- * object; <code>false</code> if it is an update count or there are no
- * more results
- * @throws java.sql.SQLException if a database access error occurs or the argument
- * supplied is not one of the following:
- * <code>Statement.CLOSE_CURRENT_RESULT</code>,
- * <code>Statement.KEEP_CURRENT_RESULT</code>, or
- * <code>Statement.CLOSE_ALL_RESULTS</code>
+ * object; <code>false</code> if it is an update count or there are no more
+ * results
+ * @throws java.sql.SQLException if a database access error occurs or the
+ * argument supplied is not one of the following:
+ * <code>Statement.CLOSE_CURRENT_RESULT</code>,
+ * <code>Statement.KEEP_CURRENT_RESULT</code>, or
+ * <code>Statement.CLOSE_ALL_RESULTS</code>
* @see #execute
* @since 1.4
*/
@@ -619,25 +597,22 @@
}
/**
- * Executes the given SQL statement and signals the driver with the
- * given flag about whether the
- * auto-generated keys produced by this <code>Statement</code> object
- * should be made available for retrieval.
+ * Executes the given SQL statement and signals the driver with the given flag
+ * about whether the auto-generated keys produced by this <code>Statement</code>
+ * object should be made available for retrieval.
*
- * @param sql must be an SQL <code>INSERT</code>, <code>UPDATE</code> or
- * <code>DELETE</code> statement or an SQL statement that
- * returns nothing
- * @param autoGeneratedKeys a flag indicating whether auto-generated keys
- * should be made available for retrieval;
- * one of the following constants:
- * <code>Statement.RETURN_GENERATED_KEYS</code>
- * <code>Statement.NO_GENERATED_KEYS</code>
- * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>
- * or <code>DELETE</code> statements, or <code>0</code> for SQL
- * statements that return nothing
+ * @param sql must be an SQL <code>INSERT</code>, <code>UPDATE</code> or
+ * <code>DELETE</code> statement or an SQL statement that returns nothing
+ * @param autoGeneratedKeys a flag indicating whether auto-generated keys should
+ * be made available for retrieval; one of the following constants:
+ * <code>Statement.RETURN_GENERATED_KEYS</code>
+ * <code>Statement.NO_GENERATED_KEYS</code>
+ * @return either the row count for <code>INSERT</code>, <code>UPDATE</code> or
+ * <code>DELETE</code> statements, or <code>0</code> for SQL statements that
+ * return nothing
* @throws java.sql.SQLException if a database access error occurs, the given
- * SQL statement returns a <code>ResultSet</code> object, or
- * the given constant is not one of those allowed
+ * SQL statement returns a <code>ResultSet</code> object, or the given constant
+ * is not one of those allowed
* @since 1.4
*/
public int executeUpdate(final String sql, int autoGeneratedKeys) throws SQLException {
@@ -646,22 +621,21 @@
/**
* Executes the given SQL statement and signals the driver that the
- * auto-generated keys indicated in the given array should be made available
- * for retrieval. The driver will ignore the array if the SQL statement
- * is not an <code>INSERT</code> statement.
+ * auto-generated keys indicated in the given array should be made available for
+ * retrieval. The driver will ignore the array if the SQL statement is not an
+ * <code>INSERT</code> statement.
*
- * @param sql an SQL <code>INSERT</code>, <code>UPDATE</code> or
- * <code>DELETE</code> statement or an SQL statement that returns nothing,
- * such as an SQL DDL statement
- * @param columnIndexes an array of column indexes indicating the columns
- * that should be returned from the inserted row
- * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>,
- * or <code>DELETE</code> statements, or 0 for SQL statements
- * that return nothing
+ * @param sql an SQL <code>INSERT</code>, <code>UPDATE</code> or
+ * <code>DELETE</code> statement or an SQL statement that returns nothing, such
+ * as an SQL DDL statement
+ * @param columnIndexes an array of column indexes indicating the columns that
+ * should be returned from the inserted row
+ * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>, or
+ * <code>DELETE</code> statements, or 0 for SQL statements that return nothing
* @throws java.sql.SQLException if a database access error occurs, the SQL
- * statement returns a <code>ResultSet</code> object, or the
- * second argument supplied to this method is not an <code>int</code> array
- * whose elements are valid column indexes
+ * statement returns a <code>ResultSet</code> object, or the second argument
+ * supplied to this method is not an <code>int</code> array whose elements are
+ * valid column indexes
* @since 1.4
*/
public int executeUpdate(final String sql, int columnIndexes[]) throws SQLException {
@@ -670,21 +644,20 @@
/**
* Executes the given SQL statement and signals the driver that the
- * auto-generated keys indicated in the given array should be made available
- * for retrieval. The driver will ignore the array if the SQL statement
- * is not an <code>INSERT</code> statement.
+ * auto-generated keys indicated in the given array should be made available for
+ * retrieval. The driver will ignore the array if the SQL statement is not an
+ * <code>INSERT</code> statement.
*
- * @param sql an SQL <code>INSERT</code>, <code>UPDATE</code> or
- * <code>DELETE</code> statement or an SQL statement that returns nothing
+ * @param sql an SQL <code>INSERT</code>, <code>UPDATE</code> or
+ * <code>DELETE</code> statement or an SQL statement that returns nothing
* @param columnNames an array of the names of the columns that should be
- * returned from the inserted row
- * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>,
- * or <code>DELETE</code> statements, or 0 for SQL statements
- * that return nothing
+ * returned from the inserted row
+ * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>, or
+ * <code>DELETE</code> statements, or 0 for SQL statements that return nothing
* @throws java.sql.SQLException if a database access error occurs, the SQL
- * statement returns a <code>ResultSet</code> object, or the
- * second argument supplied to this method is not a <code>String</code> array
- * whose elements are valid column names
+ * statement returns a <code>ResultSet</code> object, or the second argument
+ * supplied to this method is not a <code>String</code> array whose elements are
+ * valid column names
* @since 1.4
*/
public int executeUpdate(final String sql, String columnNames[]) throws SQLException {
@@ -692,37 +665,33 @@
}
/**
- * Executes the given SQL statement, which may return multiple results,
- * and signals the driver that any
- * auto-generated keys should be made available
- * for retrieval. The driver will ignore this signal if the SQL statement
- * is not an <code>INSERT</code> statement.
+ * Executes the given SQL statement, which may return multiple results, and
+ * signals the driver that any auto-generated keys should be made available for
+ * retrieval. The driver will ignore this signal if the SQL statement is not an
+ * <code>INSERT</code> statement.
* <p/>
- * In some (uncommon) situations, a single SQL statement may return
- * multiple result sets and/or update counts. Normally you can ignore
- * this unless you are (1) executing a stored procedure that you know may
- * return multiple results or (2) you are dynamically executing an
- * unknown SQL string.
+ * In some (uncommon) situations, a single SQL statement may return multiple
+ * result sets and/or update counts. Normally you can ignore this unless you are
+ * (1) executing a stored procedure that you know may return multiple results or
+ * (2) you are dynamically executing an unknown SQL string.
* <p/>
* The <code>execute</code> method executes an SQL statement and indicates the
- * form of the first result. You must then use the methods
- * <code>getResultSet</code> or <code>getUpdateCount</code>
- * to retrieve the result, and <code>getMoreResults</code> to
- * move to any subsequent result(s).
+ * form of the first result. You must then use the methods
+ * <code>getResultSet</code> or <code>getUpdateCount</code> to retrieve the
+ * result, and <code>getMoreResults</code> to move to any subsequent result(s).
*
- * @param sql any SQL statement
- * @param autoGeneratedKeys a constant indicating whether auto-generated
- * keys should be made available for retrieval using the method
- * <code>getGeneratedKeys</code>; one of the following constants:
- * <code>Statement.RETURN_GENERATED_KEYS</code> or
- * <code>Statement.NO_GENERATED_KEYS</code>
+ * @param sql any SQL statement
+ * @param autoGeneratedKeys a constant indicating whether auto-generated keys
+ * should be made available for retrieval using the method
+ * <code>getGeneratedKeys</code>; one of the following constants:
+ * <code>Statement.RETURN_GENERATED_KEYS</code> or
+ * <code>Statement.NO_GENERATED_KEYS</code>
* @return <code>true</code> if the first result is a <code>ResultSet</code>
- * object; <code>false</code> if it is an update count or there are
- * no results
+ * object; <code>false</code> if it is an update count or there are no results
* @throws java.sql.SQLException if a database access error occurs or the second
- * parameter supplied to this method is not
- * <code>Statement.RETURN_GENERATED_KEYS</code> or
- * <code>Statement.NO_GENERATED_KEYS</code>.
+ * parameter supplied to this method is not
+ * <code>Statement.RETURN_GENERATED_KEYS</code> or
+ * <code>Statement.NO_GENERATED_KEYS</code>.
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
@@ -734,36 +703,32 @@
}
/**
- * Executes the given SQL statement, which may return multiple results,
- * and signals the driver that the
- * auto-generated keys indicated in the given array should be made available
- * for retrieval. This array contains the indexes of the columns in the
- * target table that contain the auto-generated keys that should be made
- * available. The driver will ignore the array if the given SQL statement
- * is not an <code>INSERT</code> statement.
+ * Executes the given SQL statement, which may return multiple results, and
+ * signals the driver that the auto-generated keys indicated in the given array
+ * should be made available for retrieval. This array contains the indexes of
+ * the columns in the target table that contain the auto-generated keys that
+ * should be made available. The driver will ignore the array if the given SQL
+ * statement is not an <code>INSERT</code> statement.
* <p/>
- * Under some (uncommon) situations, a single SQL statement may return
- * multiple result sets and/or update counts. Normally you can ignore
- * this unless you are (1) executing a stored procedure that you know may
- * return multiple results or (2) you are dynamically executing an
- * unknown SQL string.
+ * Under some (uncommon) situations, a single SQL statement may return multiple
+ * result sets and/or update counts. Normally you can ignore this unless you are
+ * (1) executing a stored procedure that you know may return multiple results or
+ * (2) you are dynamically executing an unknown SQL string.
* <p/>
* The <code>execute</code> method executes an SQL statement and indicates the
- * form of the first result. You must then use the methods
- * <code>getResultSet</code> or <code>getUpdateCount</code>
- * to retrieve the result, and <code>getMoreResults</code> to
- * move to any subsequent result(s).
+ * form of the first result. You must then use the methods
+ * <code>getResultSet</code> or <code>getUpdateCount</code> to retrieve the
+ * result, and <code>getMoreResults</code> to move to any subsequent result(s).
*
- * @param sql any SQL statement
- * @param columnIndexes an array of the indexes of the columns in the
- * inserted row that should be made available for retrieval by a
- * call to the method <code>getGeneratedKeys</code>
+ * @param sql any SQL statement
+ * @param columnIndexes an array of the indexes of the columns in the inserted
+ * row that should be made available for retrieval by a call to the method
+ * <code>getGeneratedKeys</code>
* @return <code>true</code> if the first result is a <code>ResultSet</code>
- * object; <code>false</code> if it is an update count or there
- * are no results
+ * object; <code>false</code> if it is an update count or there are no results
* @throws java.sql.SQLException if a database access error occurs or the
- * elements in the <code>int</code> array passed to this method
- * are not valid column indexes
+ * elements in the <code>int</code> array passed to this method are not valid
+ * column indexes
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
@@ -774,36 +739,33 @@
}
/**
- * Executes the given SQL statement, which may return multiple results,
- * and signals the driver that the
- * auto-generated keys indicated in the given array should be made available
- * for retrieval. This array contains the names of the columns in the
- * target table that contain the auto-generated keys that should be made
- * available. The driver will ignore the array if the given SQL statement
- * is not an <code>INSERT</code> statement.
+ * Executes the given SQL statement, which may return multiple results, and
+ * signals the driver that the auto-generated keys indicated in the given array
+ * should be made available for retrieval. This array contains the names of the
+ * columns in the target table that contain the auto-generated keys that should
+ * be made available. The driver will ignore the array if the given SQL
+ * statement is not an <code>INSERT</code> statement.
* <p/>
- * In some (uncommon) situations, a single SQL statement may return
- * multiple result sets and/or update counts. Normally you can ignore
- * this unless you are (1) executing a stored procedure that you know may
- * return multiple results or (2) you are dynamically executing an
- * unknown SQL string.
+ * In some (uncommon) situations, a single SQL statement may return multiple
+ * result sets and/or update counts. Normally you can ignore this unless you are
+ * (1) executing a stored procedure that you know may return multiple results or
+ * (2) you are dynamically executing an unknown SQL string.
* <p/>
* The <code>execute</code> method executes an SQL statement and indicates the
- * form of the first result. You must then use the methods
- * <code>getResultSet</code> or <code>getUpdateCount</code>
- * to retrieve the result, and <code>getMoreResults</code> to
- * move to any subsequent result(s).
+ * form of the first result. You must then use the methods
+ * <code>getResultSet</code> or <code>getUpdateCount</code> to retrieve the
+ * result, and <code>getMoreResults</code> to move to any subsequent result(s).
*
- * @param sql any SQL statement
- * @param columnNames an array of the names of the columns in the inserted
- * row that should be made available for retrieval by a call to the
- * method <code>getGeneratedKeys</code>
+ * @param sql any SQL statement
+ * @param columnNames an array of the names of the columns in the inserted row
+ * that should be made available for retrieval by a call to the method
+ * <code>getGeneratedKeys</code>
* @return <code>true</code> if the next result is a <code>ResultSet</code>
- * object; <code>false</code> if it is an update count or there
- * are no more results
+ * object; <code>false</code> if it is an update count or there are no more
+ * results
* @throws java.sql.SQLException if a database access error occurs or the
- * elements of the <code>String</code> array passed to this
- * method are not valid column names
+ * elements of the <code>String</code> array passed to this method are not valid
+ * column names
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
@@ -819,7 +781,7 @@
* generated by this <code>Statement</code> object.
*
* @return either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
- * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
+ * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
* @throws java.sql.SQLException if a database access error occurs
* @since 1.4
*/
@@ -865,8 +827,7 @@
public boolean isCloseOnCompletion() throws SQLException {
if (DataSourceObjectBuilder.isJDBC41()) {
try {
- return (Boolean) executor.invokeMethod(jdbcStatement,
- "isCloseOnCompletion", null);
+ return (Boolean) executor.invokeMethod(jdbcStatement, "isCloseOnCompletion", null);
} catch (ResourceException ex) {
_logger.log(Level.SEVERE, "jdbc.ex_stmt_wrapper", ex);
throw new SQLException(ex);
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/Cache.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/Cache.java
index 2611b26..71c3313 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/Cache.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/Cache.java
@@ -25,64 +25,63 @@
public interface Cache {
/**
- * Check if an entry is found for this key object. If found, the entry is
- * put in the result object and back into the list.
+ * Check if an entry is found for this key object. If found, the entry is put in
+ * the result object and back into the list.
*
* @param key whose mapping entry is to be checked.
- * @return result object that contains the key with the entry if not busy
- * or null when
- * (1) object not found in cache
- * (2) object found but is busy
+ * @return result object that contains the key with the entry if not busy or
+ * null when (1) object not found in cache (2) object found but is busy
*/
- public Object checkAndUpdateCache(CacheObjectKey key);
+ Object checkAndUpdateCache(CacheObjectKey key);
/**
* Add key and entry value into the cache.
+ *
* @param key that contains the sql string and its type (PS/CS)
- * @param entry that is the wrapper of PreparedStatement or
- * CallableStatement
+ * @param entry that is the wrapper of PreparedStatement or CallableStatement
* @param force If existing key is to be overwritten
*/
- public void addToCache(CacheObjectKey key, Object entry, boolean force);
+ void addToCache(CacheObjectKey key, Object entry, boolean force);
/**
* Clear statement cache
*/
- public void clearCache();
+ void clearCache();
/**
- * Remove all statements stored in the statement cache after closing
- * the statement objects. Used when the statement cache size exceeds
- * user defined maximum cache size.
+ * Remove all statements stored in the statement cache after closing the
+ * statement objects. Used when the statement cache size exceeds user defined
+ * maximum cache size.
*/
- public void purge();
+ void purge();
/**
- * Closing all statements in statement cache and flush the statement cache
- * of all the statements. Used when a physical connection to the underlying
+ * Closing all statements in statement cache and flush the statement cache of
+ * all the statements. Used when a physical connection to the underlying
* resource manager is destroyed.
*/
- public void flushCache();
+ void flushCache();
/**
* Get the size of statement cache
+ *
* @return int statement cache size
*/
- public int getSize();
+ int getSize();
/**
* Check if the statement cache is synchronized.
+ *
* @return boolean synchronized flag.
*/
- public boolean isSynchronized();
+ boolean isSynchronized();
/**
- * Remove the specified entry stored in the statement cache after closing
- * the statement object associated with this entry. Used when statement is
- * being reclaimed and is being used for the subsequent requests from the
- * application.
+ * Remove the specified entry stored in the statement cache after closing the
+ * statement object associated with this entry. Used when statement is being
+ * reclaimed and is being used for the subsequent requests from the application.
*
* @param entry
*/
- public void purge(Object entry);
+ void purge(Object entry);
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/CacheFactory.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/CacheFactory.java
index 51acc7f..6cecdc3 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/CacheFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/CacheFactory.java
@@ -16,92 +16,85 @@
package com.sun.gjc.spi.base.datastructure;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.WARNING;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.logging.Logger;
+
+import org.glassfish.resourcebase.resources.api.PoolInfo;
+
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.gjc.common.DataSourceObjectBuilder;
import com.sun.logging.LogDomains;
-import org.glassfish.resourcebase.resources.api.PoolInfo;
import jakarta.resource.ResourceException;
-import java.lang.reflect.Constructor;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.util.logging.Level;
-import java.util.logging.Logger;
/**
- * Creates an appropriate statement cache datastructure used in the
- * Resource Adapter.
+ * Creates an appropriate statement cache datastructure used in the Resource
+ * Adapter.
*
* @author Shalini M
*/
public class CacheFactory {
- protected final static Logger _logger =
- LogDomains.getLogger(CacheFactory.class, LogDomains.RSR_LOGGER);
+ protected final static Logger _logger = LogDomains.getLogger(CacheFactory.class, LogDomains.RSR_LOGGER);
- protected final static StringManager localStrings =
- StringManager.getManager(DataSourceObjectBuilder.class);
+ protected final static StringManager localStrings = StringManager.getManager(DataSourceObjectBuilder.class);
- public static Cache getDataStructure(PoolInfo poolInfo, String cacheType,
- int maxSize) throws ResourceException {
+ public static Cache getDataStructure(PoolInfo poolInfo, String cacheType, int maxSize) throws ResourceException {
Cache stmtCacheStructure;
- if(cacheType == null || cacheType.trim().equals("")) {
+ if (cacheType == null || cacheType.trim().equals("")) {
debug("Initializing LRU Cache Implementation");
stmtCacheStructure = new LRUCacheImpl(poolInfo, maxSize);
- } else if(cacheType.equals("FIXED")) {
+ } else if (cacheType.equals("FIXED")) {
debug("Initializing FIXED Cache Implementation");
stmtCacheStructure = new FIXEDCacheImpl(poolInfo, maxSize);
} else { // consider the value of cacheType as a className
- stmtCacheStructure = initCustomCacheStructurePrivileged(cacheType,
- maxSize);
+ stmtCacheStructure = initCustomCacheStructurePrivileged(cacheType, maxSize);
}
- if(!stmtCacheStructure.isSynchronized()) {
+
+ if (!stmtCacheStructure.isSynchronized()) {
return new SynchronizedCache(stmtCacheStructure);
}
+
return stmtCacheStructure;
}
- private static Cache initCustomCacheStructurePrivileged(
- final String className, final int cacheSize) throws ResourceException {
- Object result = AccessController.doPrivileged(new PrivilegedAction() {
+ private static Cache initCustomCacheStructurePrivileged(final String className, final int cacheSize) throws ResourceException {
+ Object result = AccessController.doPrivileged(new PrivilegedAction<>() {
public Object run() {
Object result = null;
try {
result = initializeCacheStructure(className, cacheSize);
} catch (Exception e) {
- _logger.log(Level.WARNING, localStrings.getString(
- "jdbc.statement-cache.datastructure.init.failure",
- className));
- _logger.log(Level.WARNING, localStrings.getString(
- "jdbc.statement-cache.datastructure.init.failure.exception",
- e));
+ _logger.log(WARNING,
+ localStrings.getString("jdbc.statement-cache.datastructure.init.failure", className));
+ _logger.log(WARNING,
+ localStrings.getString("jdbc.statement-cache.datastructure.init.failure.exception", e));
}
+
return result;
}
});
+
if (result != null) {
return (Cache) result;
- } else {
- throw new ResourceException("Unable to initalize custom DataStructure " +
- "for Statement Cahe : " + className);
}
+
+ throw new ResourceException("Unable to initalize custom DataStructure " + "for Statement Cahe : " + className);
}
- private static Cache initializeCacheStructure(String className,
- int maxSize) throws Exception {
- Cache ds;
- Object[] constructorParameters = new Object[]{maxSize};
+ private static Cache initializeCacheStructure(String className, int maxSize) throws Exception {
+ Class<?> class1 = Class.forName(className);
- Class class1 = Class.forName(className);
- Constructor constructor = class1.getConstructor(class1, Integer.class);
- ds = (Cache) constructor.newInstance(constructorParameters);
- return ds;
+ return (Cache) class1.getConstructor(class1, Integer.class)
+ .newInstance(new Object[] { maxSize });
}
private static void debug(String debugStatement) {
- if(_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, debugStatement);
- }
+ _logger.log(FINE, debugStatement);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/FIXEDCacheImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/FIXEDCacheImpl.java
index 5894e3c..20696a1 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/FIXEDCacheImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/FIXEDCacheImpl.java
@@ -16,9 +16,10 @@
package com.sun.gjc.spi.base.datastructure;
+import org.glassfish.resourcebase.resources.api.PoolInfo;
+
import com.sun.gjc.spi.base.CacheObjectKey;
import com.sun.gjc.spi.base.PreparedStatementWrapper;
-import org.glassfish.resourcebase.resources.api.PoolInfo;
/**
* This ia a FIXED size cache implementation.
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/LRUCacheImpl.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/LRUCacheImpl.java
index f986477..0ef4a89 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/LRUCacheImpl.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/spi/base/datastructure/LRUCacheImpl.java
@@ -16,12 +16,6 @@
package com.sun.gjc.spi.base.datastructure;
-import com.sun.gjc.monitoring.StatementCacheProbeProvider;
-import com.sun.gjc.spi.base.CacheObjectKey;
-import com.sun.gjc.spi.base.PreparedStatementWrapper;
-import com.sun.logging.LogDomains;
-import org.glassfish.resourcebase.resources.api.PoolInfo;
-
import java.sql.SQLException;
import java.util.Iterator;
import java.util.LinkedHashMap;
@@ -30,81 +24,92 @@
import java.util.logging.Level;
import java.util.logging.Logger;
+import org.glassfish.resourcebase.resources.api.PoolInfo;
+
+import com.sun.gjc.monitoring.StatementCacheProbeProvider;
+import com.sun.gjc.spi.base.CacheObjectKey;
+import com.sun.gjc.spi.base.PreparedStatementWrapper;
+import com.sun.logging.LogDomains;
+
/**
*
* @author Shalini M
*/
public class LRUCacheImpl implements Cache {
+ protected final static Logger _logger = LogDomains.getLogger(LRUCacheImpl.class, LogDomains.RSR_LOGGER);
+
/**
* Stores the objects for statement caching
*/
private Map<CacheObjectKey, CacheEntry> list;
+
/**
* Size of the cache
*/
- private int maxSize ;
- protected final static Logger _logger;
- private StatementCacheProbeProvider probeProvider = null;
+ private int maxSize;
+ private StatementCacheProbeProvider probeProvider;
private PoolInfo poolInfo;
- static {
- _logger = LogDomains.getLogger(LRUCacheImpl.class, LogDomains.RSR_LOGGER);
- }
- public LRUCacheImpl(PoolInfo poolInfo, int maxSize){
+ public LRUCacheImpl(PoolInfo poolInfo, int maxSize) {
this.maxSize = maxSize;
this.poolInfo = poolInfo;
list = new LinkedHashMap<CacheObjectKey, CacheEntry>();
+
try {
probeProvider = new StatementCacheProbeProvider();
- } catch(Exception ex) {
- //TODO logger
+ } catch (Exception ex) {
+ // TODO logger
}
}
/**
- * Check if an entry is found for this key object. If found, the entry is
- * put in the result object and back into the list.
+ * Check if an entry is found for this key object. If found, the entry is put in
+ * the result object and back into the list.
*
* @param key key whose mapping entry is to be checked.
- * @return result object that contains the key with the entry if not
- * null when
+ * @return result object that contains the key with the entry if not null when
* (1) object not found in cache
*/
public Object checkAndUpdateCache(CacheObjectKey key) {
Object result = null;
+
CacheEntry entry = list.get(key);
- if(entry != null) {
- //Cache hit
+ if (entry != null) {
+ // Cache hit
result = entry.entryObj;
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Cache Hit");
- }
- //TODO-SC Busy cache hits?
- probeProvider.statementCacheHitEvent(poolInfo.getName(), poolInfo.getApplicationName(), poolInfo.getModuleName());
+ _logger.finest("Cache Hit");
+
+ // TODO-SC Busy cache hits?
+ probeProvider.statementCacheHitEvent(
+ poolInfo.getName(),
+ poolInfo.getApplicationName(),
+ poolInfo.getModuleName());
} else {
- //Cache miss
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Cache Miss");
- }
- probeProvider.statementCacheMissEvent(poolInfo.getName(), poolInfo.getApplicationName(), poolInfo.getModuleName());
+ // Cache miss
+ _logger.finest("Cache Miss");
+ probeProvider.statementCacheMissEvent(
+ poolInfo.getName(),
+ poolInfo.getApplicationName(),
+ poolInfo.getModuleName());
}
+
return result;
}
/**
* Add the key and entry value into the cache.
+ *
* @param key key that contains the sql string and its type (PS/CS)
- * @param o entry that is the wrapper of PreparedStatement or
- * CallableStatement
+ * @param o entry that is the wrapper of PreparedStatement or CallableStatement
* @param force If the already existing key is to be overwritten
*/
public void addToCache(CacheObjectKey key, Object o, boolean force) {
- if(force || !list.containsKey(key)){
- //overwrite or if not already found in cache
+ if (force || !list.containsKey(key)) {
+ // overwrite or if not already found in cache
- if(list.size() >= maxSize){
+ if (list.size() >= maxSize) {
purge();
}
CacheEntry entry = new CacheEntry(o);
@@ -115,15 +120,13 @@
/**
* Clears the statement cache
*/
- public void clearCache(){
- if (_logger.isLoggable(Level.FINE)) {
- _logger.fine("clearing objects in cache");
- }
- list.clear();
+ public void clearCache() {
+ _logger.fine("clearing objects in cache");
+ list.clear();
}
public void flushCache() {
- while(list.size()!=0){
+ while (list.size() != 0) {
purge();
}
}
@@ -131,20 +134,18 @@
public void purge() {
Set<Map.Entry<CacheObjectKey, CacheEntry>> entrySet = list.entrySet();
Iterator entrySetIterator = entrySet.iterator();
-// Iterator keyIterator = list.keySet().iterator();
- while(entrySetIterator.hasNext()){
-// CacheObjectKey key = (CacheObjectKey) entrySetIterator.next();
- Map.Entry<CacheObjectKey, CacheEntry> entryTuple =
- (Map.Entry<CacheObjectKey, CacheEntry>) entrySetIterator.next();
+ while (entrySetIterator.hasNext()) {
+ Map.Entry<CacheObjectKey, CacheEntry> entryTuple = (Map.Entry<CacheObjectKey, CacheEntry>) entrySetIterator
+ .next();
CacheEntry entry = entryTuple.getValue();
- try{
- //TODO Move to a more generic Contract and invoke close()
- //PreparedStatementWrapper could implement the contract instead
- PreparedStatementWrapper ps = (PreparedStatementWrapper)entry.entryObj;
+ try {
+ // TODO Move to a more generic Contract and invoke close()
+ // PreparedStatementWrapper could implement the contract instead
+ PreparedStatementWrapper ps = (PreparedStatementWrapper) entry.entryObj;
ps.setCached(false);
ps.close();
- }catch(SQLException e){
- //ignore
+ } catch (SQLException e) {
+ // ignore
}
entrySetIterator.remove();
break;
@@ -156,27 +157,23 @@
PreparedStatementWrapper tmpPS = (PreparedStatementWrapper) obj;
Set<Map.Entry<CacheObjectKey, CacheEntry>> entrySet = list.entrySet();
Iterator entrySetIterator = entrySet.iterator();
-// Iterator keyIterator = list.keySet().iterator();
- while(entrySetIterator.hasNext()){
-// CacheObjectKey key = (CacheObjectKey)keyIterator.next();
-// CacheEntry entry = list.get(key);
- Map.Entry<CacheObjectKey, CacheEntry> entryTuple =
- (Map.Entry<CacheObjectKey, CacheEntry>) entrySetIterator.next();
+
+ while (entrySetIterator.hasNext()) {
+ Map.Entry<CacheObjectKey, CacheEntry> entryTuple = (Map.Entry<CacheObjectKey, CacheEntry>) entrySetIterator
+ .next();
CacheEntry entry = entryTuple.getValue();
- try{
- //TODO Move to a more generic Contract and invoke close()
- //PreparedStatementWrapper could implement the contract instead
- PreparedStatementWrapper ps = (PreparedStatementWrapper)entry.entryObj;
- if(ps.equals(tmpPS)) {
- //Found the entry in the cache. Remove this entry.
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST, "Purging an entry from cache");
- }
+ try {
+ // TODO Move to a more generic Contract and invoke close()
+ // PreparedStatementWrapper could implement the contract instead
+ PreparedStatementWrapper ps = (PreparedStatementWrapper) entry.entryObj;
+ if (ps.equals(tmpPS)) {
+ // Found the entry in the cache. Remove this entry.
+ _logger.log(Level.FINEST, "Purging an entry from cache");
ps.setCached(false);
ps.close();
}
- }catch(SQLException e){
- //ignore
+ } catch (SQLException e) {
+ // ignore
}
entrySetIterator.remove();
break;
@@ -185,10 +182,11 @@
/**
* Returns the number of entries in the statement cache
+ *
* @return has integer value
*/
public int getSize() {
- return list.size();
+ return list.size();
}
public int getMaxSize() {
@@ -196,26 +194,17 @@
}
/**
- * Cache object that has an entry. This is used to put inside the
- * statement cache.
+ * Cache object that has an entry. This is used to put inside the statement
+ * cache.
*/
- public static class CacheEntry{
+ public static class CacheEntry {
private Object entryObj;
- public CacheEntry(Object o){
+ public CacheEntry(Object o) {
this.entryObj = o;
}
}
- /*public Set getObjects(){
- //TODO-SC-DEFER can the set be "type-safe"
- Set set = new HashSet();
- for(CacheEntry entry : list.values()){
- set.add(entry.entryObj);
- }
- return set;
- }*/
-
public boolean isSynchronized() {
return false;
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/MethodExecutor.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/MethodExecutor.java
index 842e247..a9c2836 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/MethodExecutor.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/MethodExecutor.java
@@ -16,52 +16,52 @@
package com.sun.gjc.util;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.logging.LogDomains;
+import static java.util.logging.Level.FINEST;
-import jakarta.resource.ResourceException;
+import java.io.IOException;
+import java.io.Serializable;
+import java.io.StringBufferInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
-import java.util.Vector;
+import java.util.Enumeration;
import java.util.Properties;
+import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.logging.LogDomains;
+
+import jakarta.resource.ResourceException;
+
/**
* Execute the methods based on the parameters.
*
* @author Binod P.G
* @version 1.0, 02/07/23
*/
-public class MethodExecutor implements java.io.Serializable {
+public class MethodExecutor implements Serializable {
- private static Logger _logger;
+ private static final long serialVersionUID = 1L;
- static {
- _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- }
-
- private boolean debug = false;
+ private static Logger _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
+ private static StringManager sm = StringManager.getManager(DataSourceObjectBuilder.class);
private final static String newline = System.getProperty("line.separator");
- private static StringManager sm = StringManager.getManager(
- DataSourceObjectBuilder.class);
-
/**
* Exceute a simple set Method.
*
- * @param value Value to be set.
+ * @param value Value to be set.
* @param method <code>Method</code> object.
- * @param obj Object on which the method to be executed.
- * @throws <code>ResourceException</code>,
- * in case of the mismatch of parameter values or
- * a security violation.
+ * @param obj Object on which the method to be executed.
+ * @throws <code>ResourceException</code>, in case of the mismatch of parameter
+ * values or a security violation.
*/
public void runJavaBeanMethod(String value, Method method, Object obj) throws ResourceException {
if (value == null || value.trim().equals("")) {
@@ -74,29 +74,26 @@
values[0] = convertType(parameters[0], value);
final ResourceException[] exception = new ResourceException[1];
- AccessController
- .doPrivileged(new PrivilegedAction() {
- public Object run() {
- try {
- method.setAccessible(true);
- method.invoke(obj, values);
- } catch (IllegalAccessException | InvocationTargetException | SecurityException iae) {
- _logger.log(Level.SEVERE, "jdbc.exc_jb_val", value);
- _logger.log(Level.SEVERE, "", iae);
- String msg = sm.getString("me.access_denied",
- method.getName());
- exception[0] = new ResourceException(msg);
- } catch (IllegalArgumentException ie) {
- _logger.log(Level.SEVERE, "jdbc.exc_jb_val", value);
- _logger.log(Level.SEVERE, "", ie);
- String msg = sm
- .getString("me.illegal_args", method.getName());
- exception[0] = new ResourceException(msg);
- }
- return null;
+ AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ try {
+ method.setAccessible(true);
+ method.invoke(obj, values);
+ } catch (IllegalAccessException | InvocationTargetException | SecurityException iae) {
+ _logger.log(Level.SEVERE, "jdbc.exc_jb_val", value);
+ _logger.log(Level.SEVERE, "", iae);
+ String msg = sm.getString("me.access_denied", method.getName());
+ exception[0] = new ResourceException(msg);
+ } catch (IllegalArgumentException ie) {
+ _logger.log(Level.SEVERE, "jdbc.exc_jb_val", value);
+ _logger.log(Level.SEVERE, "", ie);
+ String msg = sm.getString("me.illegal_args", method.getName());
+ exception[0] = new ResourceException(msg);
}
- });
- if( exception[0] != null){
+ return null;
+ }
+ });
+ if (exception[0] != null) {
throw exception[0];
}
}
@@ -106,28 +103,27 @@
* Executes the method.
*
* @param method <code>Method</code> object.
- * @param obj Object on which the method to be executed.
+ * @param obj Object on which the method to be executed.
* @param values Parameter values for executing the method.
- * @throws <code>ResourceException</code>,
- * in case of the mismatch of parameter values or
- * a security violation.
+ * @throws <code>ResourceException</code>, in case of the mismatch of parameter
+ * values or a security violation.
*/
public void runMethod(Method method, Object obj, Vector values) throws ResourceException {
- Class[] parameters = method.getParameterTypes();
- if (values.size() != parameters.length) {
- return;
+ Class[] parameters = method.getParameterTypes();
+ if (values.size() != parameters.length) {
+ return;
+ }
+ Object[] actualValues = new Object[parameters.length];
+ for (int i = 0; i < parameters.length; i++) {
+ String val = (String) values.get(i);
+ if (val.trim().equals("NULL")) {
+ actualValues[i] = null;
+ } else {
+ actualValues[i] = convertType(parameters[i], val);
}
- Object[] actualValues = new Object[parameters.length];
- for (int i = 0; i < parameters.length; i++) {
- String val = (String) values.get(i);
- if (val.trim().equals("NULL")) {
- actualValues[i] = null;
- } else {
- actualValues[i] = convertType(parameters[i], val);
- }
- }
+ }
final ResourceException[] exception = new ResourceException[1];
- AccessController.doPrivileged(new PrivilegedAction() {
+ AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
method.setAccessible(true);
@@ -135,20 +131,18 @@
} catch (IllegalAccessException | InvocationTargetException | SecurityException iae) {
_logger.log(Level.SEVERE, "jdbc.exc_jb_val", values);
_logger.log(Level.SEVERE, "", iae);
- String msg = sm
- .getString("me.access_denied", method.getName());
+ String msg = sm.getString("me.access_denied", method.getName());
exception[0] = new ResourceException(msg);
} catch (IllegalArgumentException ie) {
_logger.log(Level.SEVERE, "jdbc.exc_jb_val", values);
_logger.log(Level.SEVERE, "", ie);
- String msg = sm
- .getString("me.illegal_args", method.getName());
+ String msg = sm.getString("me.illegal_args", method.getName());
exception[0] = new ResourceException(msg);
}
return null;
}
});
- if( exception[0] != null){
+ if (exception[0] != null) {
throw exception[0];
}
}
@@ -156,12 +150,11 @@
/**
* Converts the type from String to the Class type.
*
- * @param type Class name to which the conversion is required.
+ * @param type Class name to which the conversion is required.
* @param parameter String value to be converted.
* @return Converted value.
- * @throws <code>ResourceException</code>,
- * in case of the mismatch of parameter values or
- * a security violation.
+ * @throws <code>ResourceException</code>, in case of the mismatch of parameter
+ * values or a security violation.
*/
private Object convertType(Class type, String parameter) throws ResourceException {
try {
@@ -208,7 +201,8 @@
if (typeName.equals("java.util.Properties")) {
Properties p = stringToProperties(parameter);
- if (p!= null) return p;
+ if (p != null)
+ return p;
}
return parameter;
@@ -219,10 +213,9 @@
}
}
- public Object invokeMethod(Object object, String methodName,
- Class<?>[] valueTypes, Object... values) throws ResourceException {
+ public Object invokeMethod(Object object, String methodName, Class<?>[] valueTypes, Object... values) throws ResourceException {
Object returnValue = null;
- Method actualMethod ;
+ Method actualMethod;
try {
actualMethod = object.getClass().getMethod(methodName, valueTypes);
} catch (NoSuchMethodException ex) {
@@ -232,15 +225,14 @@
}
if (actualMethod != null) {
try {
- returnValue = AccessController.doPrivileged(
- (PrivilegedExceptionAction<Object>) () -> {
- actualMethod.setAccessible(true);
- return actualMethod.invoke(object, values);
- });
+ returnValue = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
+ actualMethod.setAccessible(true);
+ return actualMethod.invoke(object, values);
+ });
} catch (PrivilegedActionException e) {
- if(e.getException() != null){
+ if (e.getException() != null) {
throw new ResourceException(e.getException());
- }else{
+ } else {
throw new ResourceException(e);
}
}
@@ -248,44 +240,43 @@
return returnValue;
}
- private Properties stringToProperties(String parameter)
- {
- if (parameter == null) return null;
- String s = parameter.trim();
- if (!((s.startsWith("(") && s.endsWith(")")))) {
- return null; // not a "( .... )" syntax
- }
- s = s.substring(1,s.length()-1);
- s = s.replaceAll("(?<!\\\\),",newline); // , -> \n
- s = s.replaceAll("\\\\,",","); // escape-"," -> ,
-
- Properties p = new Properties();
- Properties prop = new Properties();
- try {
- p.load(new java.io.StringBufferInputStream(s));
- } catch (java.io.IOException ex) {
- if (_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST, "Parsing string to properties: {0}", ex.getMessage());
- }
+ private Properties stringToProperties(String parameter) {
+ if (parameter == null)
return null;
- }
- // cleanup trailing whitespace in value
- for (java.util.Enumeration propKeys = p.propertyNames();
- propKeys.hasMoreElements();) {
- String tmpKey = (String)propKeys.nextElement();
- String tmpValue = p.getProperty(tmpKey);
- // Trim spaces
- tmpValue = tmpValue.trim();
- // Quoted string.
- if (tmpValue.length() > 1 && tmpValue.startsWith("\"")
- && tmpValue.endsWith("\"")) {
- tmpValue = tmpValue.substring(1,tmpValue.length()-1);
- }
- prop.put(tmpKey, tmpValue);
- }
- if (_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST, "Parsing string to properties: {0}size:{1}", new Object[]{prop, prop.size()});
- }
- return prop;
+ String s = parameter.trim();
+ if (!((s.startsWith("(") && s.endsWith(")")))) {
+ return null; // not a "( .... )" syntax
+ }
+ s = s.substring(1, s.length() - 1);
+ s = s.replaceAll("(?<!\\\\),", newline); // , -> \n
+ s = s.replaceAll("\\\\,", ","); // escape-"," -> ,
+
+ Properties p = new Properties();
+ Properties prop = new Properties();
+ try {
+ p.load(new StringBufferInputStream(s));
+ } catch (IOException ex) {
+ _logger.log(FINEST, "Parsing string to properties: {0}", ex.getMessage());
+ return null;
+ }
+
+ // cleanup trailing whitespace in value
+ for (Enumeration propKeys = p.propertyNames(); propKeys.hasMoreElements();) {
+ String tmpKey = (String) propKeys.nextElement();
+ String tmpValue = p.getProperty(tmpKey);
+ // Trim spaces
+ tmpValue = tmpValue.trim();
+ // Quoted string.
+ if (tmpValue.length() > 1 && tmpValue.startsWith("\"") && tmpValue.endsWith("\"")) {
+ tmpValue = tmpValue.substring(1, tmpValue.length() - 1);
+ }
+ prop.put(tmpKey, tmpValue);
+ }
+
+ if (_logger.isLoggable(FINEST)) {
+ _logger.log(FINEST, "Parsing string to properties: {0}size:{1}", new Object[] { prop, prop.size() });
+ }
+
+ return prop;
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/ResultSetClosedEventListener.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/ResultSetClosedEventListener.java
index 0a16dd0..3a74810 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/ResultSetClosedEventListener.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/ResultSetClosedEventListener.java
@@ -27,8 +27,8 @@
public interface ResultSetClosedEventListener {
/**
- * Used to perform operations like statement closeOnCompletion when the
- * result set object is closed.
+ * Used to perform operations like statement closeOnCompletion when the result
+ * set object is closed.
*/
- public void resultSetClosed() throws SQLException;
+ void resultSetClosed() throws SQLException;
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTrace.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTrace.java
index 8d4e5d3..6aa0084 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTrace.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTrace.java
@@ -17,9 +17,9 @@
package com.sun.gjc.util;
/**
- * Store the sql queries executed by applications along with the number of
- * times executed and the time stamp of the last usage.
- * Used for monitoring information.
+ * Store the sql queries executed by applications along with the number of times
+ * executed and the time stamp of the last usage. Used for monitoring
+ * information.
*
* @author Shalini M
*/
@@ -90,8 +90,8 @@
}
/**
- * Check for equality of the SQLTrace with the object passed by
- * comparing the queryName stored.
+ * Check for equality of the SQLTrace with the object passed by comparing the
+ * queryName stored.
*
* @param obj against which the equality is to be checked.
* @return true or false
@@ -101,12 +101,11 @@
if (obj == null) {
return false;
}
- if(!(obj instanceof SQLTrace)) {
+ if (!(obj instanceof SQLTrace)) {
return false;
}
final SQLTrace other = (SQLTrace) obj;
- if ((this.queryName == null) || (other.queryName == null) ||
- !this.queryName.equals(other.queryName)) {
+ if ((this.queryName == null) || (other.queryName == null) || !this.queryName.equals(other.queryName)) {
return false;
}
return true;
@@ -114,6 +113,7 @@
/**
* Generate hash code for this obejct using all the fields.
+ *
* @return
*/
@Override
@@ -140,15 +140,15 @@
compare = 1;
}
if (compare == 0) {
- //same number of executions. Hence compare based on time.
+ // same number of executions. Hence compare based on time.
long timeCompare = this.getLastUsageTime() - t;
- if(timeCompare == 0) {
+ if (timeCompare == 0) {
compare = 0;
- } else if(timeCompare < 0) {
- //compare = -1;
+ } else if (timeCompare < 0) {
+ // compare = -1;
compare = 1;
} else {
- //compare = 1;
+ // compare = 1;
compare = -1;
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceCache.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceCache.java
index b69a7b3..c63b4a7 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceCache.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceCache.java
@@ -16,7 +16,6 @@
package com.sun.gjc.util;
-import com.sun.logging.LogDomains;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
@@ -25,6 +24,8 @@
import java.util.logging.Level;
import java.util.logging.Logger;
+import com.sun.logging.LogDomains;
+
/**
* Maintains the Sql Tracing Cache used to store SQL statements used by the
* applications. This is used by the JDBCRA monitoring to display the most
@@ -34,17 +35,16 @@
*/
public class SQLTraceCache {
- //List of sql trace objects
+ // List of sql trace objects
private final List<SQLTrace> list;
- //Maximum size of the cache.
+ // Maximum size of the cache.
private int numTopQueriesToReport = 10;
private long timeToKeepQueries = 60 * 1000;
private SQLTraceTimerTask sqlTraceTimerTask;
private String poolName;
private String appName;
private String moduleName;
- private final static Logger _logger = LogDomains.getLogger(SQLTraceCache.class,
- LogDomains.RSR_LOGGER);
+ private final static Logger _logger = LogDomains.getLogger(SQLTraceCache.class, LogDomains.RSR_LOGGER);
private static final String LINE_BREAK = "%%%EOL%%%";
public SQLTraceCache(String poolName, String appName, String moduleName, int maxSize, long timeToKeepQueries) {
@@ -65,23 +65,23 @@
}
/**
- * Schedule timer to perform purgeEntries on the cache after the
- * specified timeToKeepQueries delay and period.
+ * Schedule timer to perform purgeEntries on the cache after the specified
+ * timeToKeepQueries delay and period.
*/
public void scheduleTimerTask(Timer timer) {
- if(sqlTraceTimerTask != null) {
+ if (sqlTraceTimerTask != null) {
sqlTraceTimerTask.cancel();
sqlTraceTimerTask = null;
}
sqlTraceTimerTask = initializeTimerTask();
- if(timer != null) {
+ if (timer != null) {
timer.scheduleAtFixedRate(sqlTraceTimerTask, timeToKeepQueries, timeToKeepQueries);
}
- if(_logger.isLoggable(Level.FINEST)) {
+ if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("Scheduled Sql Trace Caching timer task");
}
}
@@ -91,7 +91,7 @@
*/
public synchronized void cancelTimerTask() {
- if(_logger.isLoggable(Level.FINEST)) {
+ if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("Cancelling Sql Trace Caching timer task");
}
if (sqlTraceTimerTask != null) {
@@ -106,18 +106,17 @@
* @return SQLTraceTimerTask
*/
private SQLTraceTimerTask initializeTimerTask() {
- if(_logger.isLoggable(Level.FINEST)) {
+ if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("Initializing Sql Trace Caching timer task");
}
return new SQLTraceTimerTask(this);
}
/**
- * Request for adding a sql query in the form of SQLTrace to this cache.
- * If the query is already found
- * in the list, the number of times it is executed is incremented by one
- * along with the timestamp.
- * If the query is a new one, it is added to the list.
+ * Request for adding a sql query in the form of SQLTrace to this cache. If the
+ * query is already found in the list, the number of times it is executed is
+ * incremented by one along with the timestamp. If the query is a new one, it is
+ * added to the list.
*
* @param cacheObj
* @return
@@ -127,14 +126,14 @@
if (cacheObj != null) {
int index = list.indexOf(cacheObj);
if (index != -1) {
- //If already found in the cache
- //equals is invoked here and hence comparison based on query name is done
- //Get the object at the index to update the numExecutions
- SQLTrace cache = (SQLTrace) list.get(index);
+ // If already found in the cache
+ // equals is invoked here and hence comparison based on query name is done
+ // Get the object at the index to update the numExecutions
+ SQLTrace cache = list.get(index);
cache.setNumExecutions(cache.getNumExecutions() + 1);
cache.setLastUsageTime(System.currentTimeMillis());
} else {
- //First occurrence of the query. query to be added.
+ // First occurrence of the query. query to be added.
cacheObj.setNumExecutions(1);
cacheObj.setLastUsageTime(System.currentTimeMillis());
list.add(cacheObj);
@@ -144,18 +143,18 @@
}
/**
- * Entries are removed from the list after sorting
- * them in the least frequently used order. Only numTopQueriesToReport number of
- * entries are maintained in the list after the purgeEntries.
+ * Entries are removed from the list after sorting them in the least frequently
+ * used order. Only numTopQueriesToReport number of entries are maintained in
+ * the list after the purgeEntries.
*/
public void purgeEntries() {
- synchronized(list) {
+ synchronized (list) {
Collections.sort(list, Collections.reverseOrder());
Iterator i = list.iterator();
while (i.hasNext()) {
SQLTrace cacheObj = (SQLTrace) i.next();
if (list.size() > numTopQueriesToReport) {
- if(_logger.isLoggable(Level.FINEST)) {
+ if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("removing sql=" + cacheObj.getQueryName());
}
i.remove();
@@ -163,23 +162,23 @@
break;
}
}
- //sort by most frequently used queries first
+ // sort by most frequently used queries first
Collections.sort(list);
}
}
/**
- * Returns the String representation of the list of traced sql queries
- * ordered by the number most frequently used, followed by the usage
- * timestamp. Only the top 'n' queries represented by the numTopQueriesToReport are
- * chosen for display.
+ * Returns the String representation of the list of traced sql queries ordered
+ * by the number most frequently used, followed by the usage timestamp. Only the
+ * top 'n' queries represented by the numTopQueriesToReport are chosen for
+ * display.
*
* @return string representation of the list of sql queries sorted
*/
public String getTopQueries() {
purgeEntries();
StringBuffer sb = new StringBuffer();
- for(SQLTrace cache : list) {
+ for (SQLTrace cache : list) {
sb.append(LINE_BREAK);
sb.append(cache.getQueryName());
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceDelegator.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceDelegator.java
index db65197..1a94b6c 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceDelegator.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceDelegator.java
@@ -16,35 +16,31 @@
package com.sun.gjc.util;
-import com.sun.gjc.monitoring.JdbcRAConstants;
-import com.sun.gjc.monitoring.SQLTraceProbeProvider;
+import static java.util.logging.Level.FINEST;
+
import java.util.ArrayList;
import java.util.List;
-import java.util.logging.Level;
import java.util.logging.Logger;
-import com.sun.logging.LogDomains;
import org.glassfish.api.jdbc.SQLTraceListener;
import org.glassfish.api.jdbc.SQLTraceRecord;
+import com.sun.gjc.monitoring.JdbcRAConstants;
+import com.sun.gjc.monitoring.SQLTraceProbeProvider;
+import com.sun.logging.LogDomains;
+
/**
- * Implementation of SQLTraceListener to listen to events related to a
- * sql record tracing. The registry allows multiple listeners
- * to listen to the sql tracing events. Maintains a list of listeners.
+ * Implementation of SQLTraceListener to listen to events related to a sql
+ * record tracing. The registry allows multiple listeners to listen to the sql
+ * tracing events. Maintains a list of listeners.
*
* @author Shalini M
*/
-//@Singleton
public class SQLTraceDelegator implements SQLTraceListener {
- private static Logger _logger;
+ private static Logger _logger = LogDomains.getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- static {
- _logger = LogDomains
- .getLogger(MethodExecutor.class, LogDomains.RSR_LOGGER);
- }
-
- //List of listeners
+ // List of listeners
protected List<SQLTraceListener> sqlTraceListenersList;
private String poolName;
private String appName;
@@ -63,43 +59,46 @@
}
/**
- * Add a listener to the list of sql trace listeners maintained by
- * this registry.
+ * Add a listener to the list of sql trace listeners maintained by this
+ * registry.
+ *
* @param listener
*/
public void registerSQLTraceListener(SQLTraceListener listener) {
- if(sqlTraceListenersList == null) {
- sqlTraceListenersList = new ArrayList<SQLTraceListener>();
+ if (sqlTraceListenersList == null) {
+ sqlTraceListenersList = new ArrayList<SQLTraceListener>();
}
sqlTraceListenersList.add(listener);
}
-
- public void sqlTrace(SQLTraceRecord record) {
- if (sqlTraceListenersList != null) {
- for (SQLTraceListener listener : sqlTraceListenersList) {
- try {
- listener.sqlTrace(record);
- }catch(Exception e){
- //it is possible that any of the implementations may fail processing a trace record.
- //do not propagate such failures. Log them as FINEST.
- if(_logger.isLoggable(Level.FINEST)){
- _logger.log(Level.FINEST, "exception from one of the SQL trace listeners ["+listener.getClass().getName()+"]", e);
- }
- }
- }
- }
+ public void sqlTrace(SQLTraceRecord record) {
+ if (sqlTraceListenersList != null) {
+ for (SQLTraceListener listener : sqlTraceListenersList) {
+ try {
+ listener.sqlTrace(record);
+ } catch (Exception e) {
+ // it is possible that any of the implementations may fail processing a trace
+ // record.
+ // do not propagate such failures. Log them as FINEST.
+ if (_logger.isLoggable(FINEST)) {
+ _logger.log(FINEST,
+ "exception from one of the SQL trace listeners [" + listener.getClass().getName() + "]",
+ e);
+ }
+ }
+ }
+ }
if (record != null) {
record.setPoolName(poolName);
String methodName = record.getMethodName();
- //Check if the method name is one in which sql query is used
+ // Check if the method name is one in which sql query is used
if (isMethodValidForCaching(methodName)) {
Object[] params = record.getParams();
if (params != null && params.length > 0) {
String sqlQuery = null;
for (Object param : params) {
- if(param instanceof String) {
+ if (param instanceof String) {
sqlQuery = param.toString();
}
break;
@@ -112,15 +111,15 @@
}
}
- /**
- * Check if the method name from the sql trace record can be used to
- * retrieve a sql string for caching purpose. Most of the method names do not
- * contain a sql string and hence are unusable for caching the sql strings.
- * These method names are filtered in this method.
- *
- * @param methodName
- * @return true if method name can be used to get a sql string for caching.
- */
+ /**
+ * Check if the method name from the sql trace record can be used to retrieve a
+ * sql string for caching purpose. Most of the method names do not contain a sql
+ * string and hence are unusable for caching the sql strings. These method names
+ * are filtered in this method.
+ *
+ * @param methodName
+ * @return true if method name can be used to get a sql string for caching.
+ */
private boolean isMethodValidForCaching(String methodName) {
return JdbcRAConstants.validSqlTracingMethodNames.contains(methodName);
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceLogger.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceLogger.java
index 6c000e8..f70cce8 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceLogger.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceLogger.java
@@ -16,15 +16,17 @@
package com.sun.gjc.util;
-import com.sun.logging.LogDomains;
import java.util.logging.Level;
import java.util.logging.Logger;
+
import org.glassfish.api.jdbc.SQLTraceListener;
import org.glassfish.api.jdbc.SQLTraceRecord;
+import com.sun.logging.LogDomains;
+
/**
- * Implementation of SQLTraceListener to listen to events related to a
- * sql record tracing.
+ * Implementation of SQLTraceListener to listen to events related to a sql
+ * record tracing.
*
* @author Shalini M
*/
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceTimerTask.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceTimerTask.java
index d53b634..434e151 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceTimerTask.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SQLTraceTimerTask.java
@@ -37,7 +37,7 @@
*/
@Override
public void run() {
- //Redirecting the purge operation of the cache to the cache factory
+ // Redirecting the purge operation of the cache to the cache factory
cache.purgeEntries();
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SecurityUtils.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SecurityUtils.java
index dd71311..39966fb 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SecurityUtils.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/SecurityUtils.java
@@ -16,20 +16,23 @@
package com.sun.gjc.util;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.spi.ConnectionRequestInfoImpl;
-
-import jakarta.resource.ResourceException;
-import jakarta.resource.spi.ManagedConnectionFactory;
-import jakarta.resource.spi.security.PasswordCredential;
-import javax.security.auth.Subject;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
+import javax.security.auth.Subject;
+
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.common.DataSourceObjectBuilder;
+import com.sun.gjc.spi.ConnectionRequestInfoImpl;
+
+import jakarta.resource.ResourceException;
+import jakarta.resource.spi.ConnectionRequestInfo;
+import jakarta.resource.spi.ManagedConnectionFactory;
+import jakarta.resource.spi.security.PasswordCredential;
+
/**
* SecurityUtils for Generic JDBC Connector.
*
@@ -38,51 +41,50 @@
*/
public class SecurityUtils {
- static private StringManager sm = StringManager.getManager(
- DataSourceObjectBuilder.class);
+ static private StringManager sm = StringManager.getManager(DataSourceObjectBuilder.class);
/**
- * This method returns the <code>PasswordCredential</code> object, given
- * the <code>ManagedConnectionFactory</code>, subject and the
+ * This method returns the <code>PasswordCredential</code> object, given the
+ * <code>ManagedConnectionFactory</code>, subject and the
* <code>ConnectionRequestInfo</code>. It first checks if the
- * <code>ConnectionRequestInfo</code> is null or not. If it is not null,
- * it constructs a <code>PasswordCredential</code> object with
- * the user and password fields from the <code>ConnectionRequestInfo</code> and returns this
- * <code>PasswordCredential</code> object. If the <code>ConnectionRequestInfo</code>
- * is null, it retrieves the <code>PasswordCredential</code> objects from
- * the <code>Subject</code> parameter and returns the first
- * <code>PasswordCredential</code> object which contains a
- * <code>ManagedConnectionFactory</code>, instance equivalent
- * to the <code>ManagedConnectionFactory</code>, parameter.
+ * <code>ConnectionRequestInfo</code> is null or not. If it is not null, it
+ * constructs a <code>PasswordCredential</code> object with the user and
+ * password fields from the <code>ConnectionRequestInfo</code> and returns this
+ * <code>PasswordCredential</code> object. If the
+ * <code>ConnectionRequestInfo</code> is null, it retrieves the
+ * <code>PasswordCredential</code> objects from the <code>Subject</code>
+ * parameter and returns the first <code>PasswordCredential</code> object which
+ * contains a <code>ManagedConnectionFactory</code>, instance equivalent to the
+ * <code>ManagedConnectionFactory</code>, parameter.
*
- * @param mcf <code>ManagedConnectionFactory</code>
+ * @param mcf <code>ManagedConnectionFactory</code>
* @param subject <code>Subject</code>
- * @param info <code>ConnectionRequestInfo</code>
+ * @param info <code>ConnectionRequestInfo</code>
* @return <code>PasswordCredential</code>
* @throws <code>ResourceException</code> generic exception if operation fails
- * @throws <code>SecurityException</code> if access to the <code>Subject</code> instance is denied
+ * @throws <code>SecurityException</code> if access to the <code>Subject</code>
+ * instance is denied
*/
- public static PasswordCredential getPasswordCredential(final ManagedConnectionFactory mcf,
- final Subject subject, jakarta.resource.spi.ConnectionRequestInfo info) throws ResourceException {
+ public static PasswordCredential getPasswordCredential(final ManagedConnectionFactory mcf, final Subject subject,
+ ConnectionRequestInfo info) throws ResourceException {
if (info == null) {
if (subject == null) {
return null;
} else {
- PasswordCredential pc = (PasswordCredential) AccessController.doPrivileged
- (new PrivilegedAction() {
- public Object run() {
- Set passwdCredentialSet = subject.getPrivateCredentials(PasswordCredential.class);
- Iterator iter = passwdCredentialSet.iterator();
- while (iter.hasNext()) {
- PasswordCredential temp = (PasswordCredential) iter.next();
- if (temp.getManagedConnectionFactory().equals(mcf)) {
- return temp;
- }
- }
- return null;
+ PasswordCredential pc = (PasswordCredential) AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ Set passwdCredentialSet = subject.getPrivateCredentials(PasswordCredential.class);
+ Iterator iter = passwdCredentialSet.iterator();
+ while (iter.hasNext()) {
+ PasswordCredential temp = (PasswordCredential) iter.next();
+ if (temp.getManagedConnectionFactory().equals(mcf)) {
+ return temp;
}
- });
+ }
+ return null;
+ }
+ });
if (pc == null) {
String msg = sm.getString("su.no_passwd_cred");
throw new jakarta.resource.spi.SecurityException(msg);
@@ -103,24 +105,23 @@
*
* @param str1 <code>String</code>
* @param str2 <code>String</code>
- * @return true if the two strings are equal
- * false otherwise
+ * @return true if the two strings are equal false otherwise
*/
static private boolean isEqual(String str1, String str2) {
if (str1 == null) {
return (str2 == null);
- } else {
- return str1.equals(str2);
}
+
+ return str1.equals(str2);
}
/**
- * Returns true if two <code>PasswordCredential</code> objects are equal; false otherwise
+ * Returns true if two <code>PasswordCredential</code> objects are equal; false
+ * otherwise
*
* @param pC1 <code>PasswordCredential</code>
* @param pC2 <code>PasswordCredential</code>
- * @return true if the two PasswordCredentials are equal
- * false otherwise
+ * @return true if the two PasswordCredentials are equal false otherwise
*/
static public boolean isPasswordCredentialEqual(PasswordCredential pC1, PasswordCredential pC2) {
if (pC1 == pC2)
@@ -130,6 +131,7 @@
if (!isEqual(pC1.getUserName(), pC2.getUserName())) {
return false;
}
+
return Arrays.equals(pC1.getPassword(), pC2.getPassword());
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakDetector.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakDetector.java
index 1d0c28a..5ff9448 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakDetector.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakDetector.java
@@ -16,10 +16,7 @@
package com.sun.gjc.util;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.monitoring.StatementLeakProbeProvider;
-import com.sun.logging.LogDomains;
-import org.glassfish.resourcebase.resources.api.PoolInfo;
+import static java.util.logging.Level.WARNING;
import java.sql.SQLException;
import java.sql.Statement;
@@ -28,9 +25,14 @@
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
-import java.util.logging.Level;
import java.util.logging.Logger;
+import org.glassfish.resourcebase.resources.api.PoolInfo;
+
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.monitoring.StatementLeakProbeProvider;
+import com.sun.logging.LogDomains;
+
/**
* Statement leak detector that prints the stack trace of the thread when a
* statement object is leaked. Once the leak timeout expires, a statement leak
@@ -46,18 +48,16 @@
private boolean statementLeakTracing;
private long statementLeakTimeoutInMillis;
private boolean statementLeakReclaim;
- //Lock on HashMap to trace statement leaks
+ // Lock on HashMap to trace statement leaks
private final Object statementLeakLock;
private Map<Statement, StatementLeakListener> listeners;
- private final static Logger _logger = LogDomains.getLogger(
- StatementLeakDetector.class, LogDomains.RSR_LOGGER);
- private final static StringManager localStrings =
- StringManager.getManager(StatementLeakDetector.class);
+ private final static Logger _logger = LogDomains.getLogger(StatementLeakDetector.class, LogDomains.RSR_LOGGER);
+ private final static StringManager localStrings = StringManager.getManager(StatementLeakDetector.class);
private Timer timer;
private StatementLeakProbeProvider stmtLeakProbeProvider = null;
- public StatementLeakDetector(PoolInfo poolInfo, boolean leakTracing,
- long leakTimeoutInMillis, boolean leakReclaim, Timer timer) {
+ public StatementLeakDetector(PoolInfo poolInfo, boolean leakTracing, long leakTimeoutInMillis, boolean leakReclaim,
+ Timer timer) {
this.poolInfo = poolInfo;
statementLeakThreadStackHashMap = new HashMap<Statement, StackTraceElement[]>();
statementLeakTimerTaskHashMap = new HashMap<Statement, StatementLeakTask>();
@@ -79,7 +79,6 @@
statementLeakReclaim = leakReclaim;
}
-
private void registerListener(Statement stmt, StatementLeakListener listener) {
listeners.put(stmt, listener);
}
@@ -88,12 +87,11 @@
listeners.remove(stmt);
}
-
/**
* Starts statement leak tracing
*
* @param stmt Statement which needs to be traced
- * @param listener Leak Listener
+ * @param listener Leak Listener
*/
public void startStatementLeakTracing(Statement stmt, StatementLeakListener listener) {
synchronized (statementLeakLock) {
@@ -104,9 +102,7 @@
registerListener(stmt, listener);
if (timer != null) {
timer.schedule(statementLeakTask, statementLeakTimeoutInMillis);
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Scheduled Statement leak tracing timer task");
- }
+ _logger.finest("Scheduled Statement leak tracing timer task");
}
}
}
@@ -116,25 +112,21 @@
* Stops statement leak tracing
*
* @param stmt Statement which needs to be traced
- * @param listener Leak Listener
+ * @param listener Leak Listener
*/
public void stopStatementLeakTracing(Statement stmt, StatementLeakListener listener) {
synchronized (statementLeakLock) {
if (statementLeakThreadStackHashMap.containsKey(stmt)) {
statementLeakThreadStackHashMap.remove(stmt);
- StatementLeakTask statementLeakTask =
- statementLeakTimerTaskHashMap.remove(stmt);
+ StatementLeakTask statementLeakTask = statementLeakTimerTaskHashMap.remove(stmt);
statementLeakTask.cancel();
timer.purge();
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.finest("Stopped Statement leak tracing timer task");
- }
+ _logger.finest("Stopped Statement leak tracing timer task");
unRegisterListener(stmt);
}
}
}
-
/**
* Logs the potential statement leaks
*
@@ -145,21 +137,19 @@
if (statementLeakThreadStackHashMap.containsKey(stmt)) {
StackTraceElement[] threadStack = statementLeakThreadStackHashMap.remove(stmt);
StatementLeakListener stmtLeakListener = listeners.get(stmt);
- stmtLeakProbeProvider.potentialStatementLeakEvent(poolInfo.getName(),
- poolInfo.getApplicationName(), poolInfo.getModuleName());
+ stmtLeakProbeProvider.potentialStatementLeakEvent(poolInfo.getName(), poolInfo.getApplicationName(),
+ poolInfo.getModuleName());
printStatementLeakTrace(threadStack);
statementLeakTimerTaskHashMap.remove(stmt);
if (statementLeakReclaim) {
try {
stmtLeakListener.reclaimStatement();
} catch (SQLException ex) {
- Object[] params = new Object[]{poolInfo, ex};
- _logger.log(Level.WARNING,
- "statement.leak.detector_reclaim_statement_failure",
- params);
+ Object[] params = new Object[] { poolInfo, ex };
+ _logger.log(WARNING, "statement.leak.detector_reclaim_statement_failure", params);
}
}
- //Unregister here as the listeners would still be present in the map.
+ // Unregister here as the listeners would still be present in the map.
unRegisterListener(stmt);
}
}
@@ -172,30 +162,30 @@
*/
private void printStatementLeakTrace(StackTraceElement[] threadStackTrace) {
StringBuffer stackTrace = new StringBuffer();
- String msg = localStrings.getStringWithDefault(
- "potential.statement.leak.msg",
- "A potential statement leak detected for connection pool " + poolInfo +
- ". The stack trace of the thread is provided below : ",
- new Object[]{poolInfo});
+ String msg = localStrings
+ .getStringWithDefault(
+ "potential.statement.leak.msg", "A potential statement leak detected for connection pool "
+ + poolInfo + ". The stack trace of the thread is provided below : ",
+ new Object[] { poolInfo });
stackTrace.append(msg);
stackTrace.append("\n");
for (int i = 2; i < threadStackTrace.length; i++) {
stackTrace.append(threadStackTrace[i].toString());
stackTrace.append("\n");
}
- _logger.log(Level.WARNING, stackTrace.toString(), "ConnectionPoolName=" + poolInfo);
+ _logger.log(WARNING, stackTrace.toString(), "ConnectionPoolName=" + poolInfo);
}
/**
- * Clear all statement leak tracing tasks in case of statement leak
- * tracing being turned off
+ * Clear all statement leak tracing tasks in case of statement leak tracing
+ * being turned off
*/
public void clearAllStatementLeakTasks() {
synchronized (statementLeakLock) {
- Iterator<Map.Entry<Statement, StatementLeakTask>> entryIterator =
- statementLeakTimerTaskHashMap.entrySet().iterator();
+ Iterator<Map.Entry<Statement, StatementLeakTask>> entryIterator = statementLeakTimerTaskHashMap.entrySet()
+ .iterator();
while (entryIterator.hasNext()) {
- Map.Entry<Statement,StatementLeakTask> entry = entryIterator.next();
+ Map.Entry<Statement, StatementLeakTask> entry = entryIterator.next();
StatementLeakTask statementLeakTask = entry.getValue();
statementLeakTask.cancel();
}
@@ -206,7 +196,6 @@
}
}
-
private class StatementLeakTask extends TimerTask {
private Statement statement;
diff --git a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakListener.java b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakListener.java
index f4c268e..5bdce2b 100644
--- a/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakListener.java
+++ b/appserver/jdbc/jdbc-ra/jdbc-core/src/main/java/com/sun/gjc/util/StatementLeakListener.java
@@ -30,6 +30,6 @@
/**
* Reclaim the leaked statement
*/
- public void reclaimStatement() throws SQLException;
+ void reclaimStatement() throws SQLException;
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/CallableStatementWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/CallableStatementWrapper40.java
index 366cc53..65176ec 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/CallableStatementWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/CallableStatementWrapper40.java
@@ -16,13 +16,24 @@
package com.sun.gjc.spi.jdbc40;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.spi.base.CallableStatementWrapper;
+import static com.sun.gjc.common.DataSourceObjectBuilder.isJDBC41;
+import static java.util.logging.Level.SEVERE;
import java.io.InputStream;
import java.io.Reader;
-import java.sql.*;
-import java.util.logging.Level;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.NClob;
+import java.sql.ResultSet;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.SQLXML;
+
+import com.sun.gjc.spi.base.CallableStatementWrapper;
+
import jakarta.resource.ResourceException;
/**
@@ -32,12 +43,10 @@
/**
* Creates a new instance of CallableStatement wrapper for JDBC 3.0<br>
*
- * @param con ConnectionWrapper<br>
+ * @param con ConnectionWrapper<br>
* @param statement CallableStatement that is wrapped<br>
*/
- public CallableStatementWrapper40(Connection con, CallableStatement statement,
- boolean cachingEnabled)
- throws SQLException {
+ public CallableStatementWrapper40(Connection con, CallableStatement statement, boolean cachingEnabled) throws SQLException {
super(con, statement, cachingEnabled);
}
@@ -47,12 +56,14 @@
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @return a <code>java.io.Reader</code> object that contains the parameter
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language.
- * @throws SQLException if the parameterIndex is not valid; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
+ * value; if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language.
+ * @throws SQLException if the parameterIndex is not valid; if a database access
+ * error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
* @since 1.6
*/
+ @Override
public Reader getCharacterStream(int parameterIndex) throws SQLException {
return callableStatement.getCharacterStream(parameterIndex);
}
@@ -63,62 +74,60 @@
*
* @param parameterName the name of the parameter
* @return a <code>java.io.Reader</code> object that contains the parameter
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language
+ * value; if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public Reader getCharacterStream(String parameterName) throws SQLException {
return callableStatement.getCharacterStream(parameterName);
}
/**
* Retrieves the value of the designated parameter as a
- * <code>java.io.Reader</code> object in the Java programming language.
- * It is intended for use when
- * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> parameters.
+ * <code>java.io.Reader</code> object in the Java programming language. It is
+ * intended for use when accessing <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> parameters.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @return a <code>java.io.Reader</code> object that contains the parameter
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language.
- * @throws SQLException if the parameterIndex is not valid;
- * if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * value; if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language.
+ * @throws SQLException if the parameterIndex is not valid; if a database access
+ * error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public Reader getNCharacterStream(int parameterIndex) throws SQLException {
return callableStatement.getNCharacterStream(parameterIndex);
}
/**
* Retrieves the value of the designated parameter as a
- * <code>java.io.Reader</code> object in the Java programming language.
- * It is intended for use when
- * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> parameters.
+ * <code>java.io.Reader</code> object in the Java programming language. It is
+ * intended for use when accessing <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> parameters.
*
* @param parameterName the name of the parameter
* @return a <code>java.io.Reader</code> object that contains the parameter
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language
+ * value; if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public Reader getNCharacterStream(String parameterName) throws SQLException {
return callableStatement.getNCharacterStream(parameterName);
}
@@ -127,21 +136,19 @@
* Retrieves the value of the designated JDBC <code>NCLOB</code> parameter as a
* <code>java.sql.NClob</code> object in the Java programming language.
*
- * @param parameterIndex the first parameter is 1, the second is 2, and
- * so on
- * @return the parameter value as a <code>NClob</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>, the
- * value <code>null</code> is returned.
- * @throws SQLException if the parameterIndex is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param parameterIndex the first parameter is 1, the second is 2, and so on
+ * @return the parameter value as a <code>NClob</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
+ * @throws SQLException if the parameterIndex is not valid; if the driver does
+ * not support national character sets; if the driver can detect that a data
+ * conversion error could occur; if a database access error occurs or this
+ * method is called on a closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public NClob getNClob(int parameterIndex) throws SQLException {
return callableStatement.getNClob(parameterIndex);
}
@@ -151,76 +158,69 @@
* <code>java.sql.NClob</code> object in the Java programming language.
*
* @param parameterName the name of the parameter
- * @return the parameter value as a <code>NClob</code> object in the
- * Java programming language. If the value was SQL <code>NULL</code>,
- * the value <code>null</code> is returned.
+ * @return the parameter value as a <code>NClob</code> object in the Java
+ * programming language. If the value was SQL <code>NULL</code>, the value
+ * <code>null</code> is returned.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if the driver does not support national character sets; if the
+ * driver can detect that a data conversion error could occur; if a database
+ * access error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public NClob getNClob(String parameterName) throws SQLException {
return callableStatement.getNClob(parameterName);
}
/**
* Retrieves the value of the designated <code>NCHAR</code>,
- * <code>NVARCHAR</code>
- * or <code>LONGNVARCHAR</code> parameter as
- * a <code>String</code> in the Java programming language.
+ * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> parameter as a
+ * <code>String</code> in the Java programming language.
* <p/>
- * For the fixed-length type JDBC <code>NCHAR</code>,
- * the <code>String</code> object
- * returned has exactly the same value the SQL
- * <code>NCHAR</code> value had in the
- * database, including any padding added by the database.
+ * For the fixed-length type JDBC <code>NCHAR</code>, the <code>String</code>
+ * object returned has exactly the same value the SQL <code>NCHAR</code> value
+ * had in the database, including any padding added by the database.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @return a <code>String</code> object that maps an
- * <code>NCHAR</code>, <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
- * @throws SQLException if the parameterIndex is not valid;
- * if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @return a <code>String</code> object that maps an <code>NCHAR</code>,
+ * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
+ * @throws SQLException if the parameterIndex is not valid; if a database access
+ * error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @see #setNString
* @since 1.6
*/
+ @Override
public String getNString(int parameterIndex) throws SQLException {
return callableStatement.getNString(parameterIndex);
}
/**
* Retrieves the value of the designated <code>NCHAR</code>,
- * <code>NVARCHAR</code>
- * or <code>LONGNVARCHAR</code> parameter as
- * a <code>String</code> in the Java programming language.
+ * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> parameter as a
+ * <code>String</code> in the Java programming language.
* <p/>
- * For the fixed-length type JDBC <code>NCHAR</code>,
- * the <code>String</code> object
- * returned has exactly the same value the SQL
- * <code>NCHAR</code> value had in the
- * database, including any padding added by the database.
+ * For the fixed-length type JDBC <code>NCHAR</code>, the <code>String</code>
+ * object returned has exactly the same value the SQL <code>NCHAR</code> value
+ * had in the database, including any padding added by the database.
*
* @param parameterName the name of the parameter
- * @return a <code>String</code> object that maps an
- * <code>NCHAR</code>, <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
+ * @return a <code>String</code> object that maps an <code>NCHAR</code>,
+ * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
* @throws SQLException if parameterName does not correspond to a named
- * parameter;
- * if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @see #setNString
* @since 1.6
*/
+ @Override
public String getNString(String parameterName) throws SQLException {
return callableStatement.getNString(parameterName);
}
@@ -230,17 +230,18 @@
* <code>java.sql.RowId</code> object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
- * @return a <code>RowId</code> object that represents the JDBC <code>ROWID</code>
- * value is used as the designated parameter. If the parameter contains
- * a SQL <code>NULL</code>, then a <code>null</code> value is returned.
- * @throws SQLException if the parameterIndex is not valid;
- * if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @return a <code>RowId</code> object that represents the JDBC
+ * <code>ROWID</code> value is used as the designated parameter. If the
+ * parameter contains a SQL <code>NULL</code>, then a <code>null</code> value is
+ * returned.
+ * @throws SQLException if the parameterIndex is not valid; if a database access
+ * error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public RowId getRowId(int parameterIndex) throws SQLException {
return callableStatement.getRowId(parameterIndex);
}
@@ -250,17 +251,18 @@
* <code>java.sql.RowId</code> object.
*
* @param parameterName the name of the parameter
- * @return a <code>RowId</code> object that represents the JDBC <code>ROWID</code>
- * value is used as the designated parameter. If the parameter contains
- * a SQL <code>NULL</code>, then a <code>null</code> value is returned.
+ * @return a <code>RowId</code> object that represents the JDBC
+ * <code>ROWID</code> value is used as the designated parameter. If the
+ * parameter contains a SQL <code>NULL</code>, then a <code>null</code> value is
+ * returned.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public RowId getRowId(String parameterName) throws SQLException {
return callableStatement.getRowId(parameterName);
}
@@ -271,14 +273,14 @@
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
* @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
- * @throws SQLException if the parameterIndex is not valid;
- * if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @throws SQLException if the parameterIndex is not valid; if a database access
+ * error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public SQLXML getSQLXML(int parameterIndex) throws SQLException {
return callableStatement.getSQLXML(parameterIndex);
}
@@ -290,1048 +292,1102 @@
* @param parameterName the name of the parameter
* @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public SQLXML getSQLXML(String parameterName) throws SQLException {
return callableStatement.getSQLXML(parameterName);
}
/**
- * Sets the designated parameter to the given input stream.
- * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * Sets the designated parameter to the given input stream. When a very large
+ * ASCII value is input to a <code>LONGVARCHAR</code> parameter, it may be more
+ * practical to send it via a <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setAsciiStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setAsciiStream</code> which takes
+ * a length parameter.
*
* @param parameterName the name of the parameter
- * @param x the Java input stream that contains the ASCII parameter value
+ * @param x the Java input stream that contains the ASCII parameter value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
callableStatement.setAsciiStream(parameterName, 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * 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</code> parameter, it may be more practical to send it via a
+ * <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
*
* @param parameterName the name of the parameter
- * @param x the Java input stream that contains the ASCII parameter value
- * @param length the number of bytes in the stream
+ * @param x the Java input stream that contains the ASCII parameter value
+ * @param length the number of bytes in the stream
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
callableStatement.setAsciiStream(parameterName, x, length);
}
/**
- * Sets the designated parameter to the given input stream.
- * When a very large binary value is input to a <code>LONGVARBINARY</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the
- * stream as needed until end-of-file is reached.
+ * Sets the designated parameter to the given input stream. When a very large
+ * binary value is input to a <code>LONGVARBINARY</code> parameter, it may be
+ * more practical to send it via a <code>java.io.InputStream</code> object. The
+ * data will be read from the stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setBinaryStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setBinaryStream</code> which
+ * takes a length parameter.
*
* @param parameterName the name of the parameter
- * @param x the java input stream which contains the binary parameter value
+ * @param x the java input stream which contains the binary parameter value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
callableStatement.setBinaryStream(parameterName, x);
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the stream
- * as needed until end-of-file is reached.
+ * 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</code> parameter, it may be more practical to send it via
+ * a <code>java.io.InputStream</code> object. The data will be read from the
+ * stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
*
* @param parameterName the name of the parameter
- * @param x the java input stream which contains the binary parameter value
- * @param length the number of bytes in the stream
+ * @param x the java input stream which contains the binary parameter value
+ * @param length the number of bytes in the stream
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
callableStatement.setBinaryStream(parameterName, x, length);
}
/**
* Sets the designated parameter to the given <code>java.sql.Blob</code> object.
- * The driver converts this to an SQL <code>BLOB</code> value when it
- * sends it to the database.
+ * The driver converts this to an SQL <code>BLOB</code> value when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
+ * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(String parameterName, Blob x) throws SQLException {
callableStatement.setBlob(parameterName, x);
}
/**
- * Sets the designated parameter to a <code>InputStream</code> object.
- * This method differs from the <code>setBinaryStream (int, InputStream)</code>
- * method because it informs the driver that the parameter value should be
- * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
- * the driver may have to do extra work to determine whether the parameter
- * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
+ * Sets the designated parameter to a <code>InputStream</code> object. This
+ * method differs from the <code>setBinaryStream (int, InputStream)</code>
+ * method because it informs the driver that the parameter value should be sent
+ * to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code>
+ * method is used, the driver may have to do extra work to determine whether the
+ * parameter data should be send to the server as a <code>LONGVARBINARY</code>
+ * or a <code>BLOB</code>
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setBlob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setBlob</code> which takes a
+ * length parameter.
*
* @param parameterName the name of the parameter
- * @param inputStream An object that contains the data to set the parameter
- * value to.
+ * @param inputStream An object that contains the data to set the parameter
+ * value to.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
callableStatement.setBlob(parameterName, inputStream);
}
/**
- * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number
- * of characters specified by length, otherwise a <code>SQLException</code> will be
- * generated when the <code>CallableStatement</code> is executed.
- * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
- * method because it informs the driver that the parameter value should be
- * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
- * the driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
+ * Sets the designated parameter to a <code>InputStream</code> object. The
+ * <code>inputstream</code> must contain the number of characters specified by
+ * length, otherwise a <code>SQLException</code> will be generated when the
+ * <code>CallableStatement</code> is executed. This method differs from the
+ * <code>setBinaryStream (int, InputStream, int)</code> method because it
+ * informs the driver that the parameter value should be sent to the server as a
+ * <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, the
+ * driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGVARBINARY</code> or a
+ * <code>BLOB</code>
*
- * @param parameterName the name of the parameter to be set
- * the second is 2, ...
- * @param inputStream An object that contains the data to set the parameter
- * value to.
- * @param length the number of bytes in the parameter data.
+ * @param parameterName the name of the parameter to be set the second is 2, ...
+ * @param inputStream An object that contains the data to set the parameter
+ * value to.
+ * @param length the number of bytes in the parameter data.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the length specified
- * is less than zero; if the number of bytes in the inputstream does not match
- * the specfied length; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if the length specified is less than zero; if the number of bytes
+ * in the inputstream does not match the specfied length; if a database access
+ * error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
callableStatement.setBlob(parameterName, inputStream, length);
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object. When a
+ * very large UNICODE value is input to a <code>LONGVARCHAR</code> parameter, it
+ * may be more practical to send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setCharacterStream</code> which
+ * takes a length parameter.
*
* @param parameterName the name of the parameter
- * @param reader the <code>java.io.Reader</code> object that contains the
- * Unicode data
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * Unicode data
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
callableStatement.setCharacterStream(parameterName, reader);
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object, which
+ * is the given number of characters long. When a very large UNICODE value is
+ * input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
*
* @param parameterName the name of the parameter
- * @param reader the <code>java.io.Reader</code> object that
- * contains the UNICODE data used as the designated parameter
- * @param length the number of characters in the stream
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * UNICODE data used as the designated parameter
+ * @param length the number of characters in the stream
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
callableStatement.setCharacterStream(parameterName, reader, length);
}
/**
* Sets the designated parameter to the given <code>java.sql.Clob</code> object.
- * The driver converts this to an SQL <code>CLOB</code> value when it
- * sends it to the database.
+ * The driver converts this to an SQL <code>CLOB</code> value when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
+ * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(String parameterName, Clob x) throws SQLException {
callableStatement.setClob(parameterName, x);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be send to the server as a <code>LONGVARCHAR</code> or a
+ * <code>CLOB</code>
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setClob</code> which takes a
+ * length parameter.
*
* @param parameterName the name of the parameter
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or this method is called on
- * a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(String parameterName, Reader reader) throws SQLException {
callableStatement.setClob(parameterName, reader);
}
/**
* Sets the designated parameter to a <code>Reader</code> object. The
- * <code>Reader</code> reads the data till end-of-file is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
+ * <code>Reader</code> reads the data till end-of-file is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNCharacterStream</code> which
+ * takes a length parameter.
*
* @param parameterName the name of the parameter
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if the driver does not support national character sets; if the
+ * driver can detect that a data conversion error could occur; if a database
+ * access error occurs; or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
callableStatement.setNCharacterStream(parameterName, value);
}
/**
* Sets the designated parameter to a <code>Reader</code> object. The
- * <code>Reader</code> reads the data till end-of-file is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
+ * <code>Reader</code> reads the data till end-of-file is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database.
*
* @param parameterName the name of the parameter to be set
- * @param value the parameter value
- * @param length the number of characters in the parameter data.
+ * @param value the parameter value
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if the driver does not support national character sets; if the
+ * driver can detect that a data conversion error could occur; if a database
+ * access error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
callableStatement.setNCharacterStream(parameterName, value, length);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNClob</code> which takes a length parameter.
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be send to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNClob</code> which takes a
+ * length parameter.
*
* @param parameterName the name of the parameter
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the driver does not support national character sets;
- * if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if the driver does not support national character sets; if the
+ * driver can detect that a data conversion error could occur; if a database
+ * access error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(String parameterName, NClob reader) throws SQLException {
callableStatement.setNClob(parameterName, reader);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>CallableStatement</code> is executed.
- * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. The
+ * <code>reader</code> must contain the number of characters specified by length
+ * otherwise a <code>SQLException</code> will be generated when the
+ * <code>CallableStatement</code> is executed. This method differs from the
+ * <code>setCharacterStream (int, Reader, int)</code> method because it informs
+ * the driver that the parameter value should be sent to the server as a
+ * <code>CLOB</code>. When the <code>setCharacterStream</code> method is used,
+ * the driver may have to do extra work to determine whether the parameter data
+ * should be send to the server as a <code>LONGVARCHAR</code> or a
+ * <code>CLOB</code>
*
* @param parameterName the name of the parameter to be set
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the length specified is less than zero;
- * a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if the length specified is less than zero; a database access error
+ * occurs or this method is called on a closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(String parameterName, Reader reader, long length) throws SQLException {
callableStatement.setClob(parameterName, reader, length);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNClob</code> which takes a length parameter.
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be send to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNClob</code> which takes a
+ * length parameter.
*
* @param parameterName the name of the parameter
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the driver does not support national character sets;
- * if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * parameter; if the driver does not support national character sets; if the
+ * driver can detect that a data conversion error could occur; if a database
+ * access error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(String parameterName, Reader reader) throws SQLException {
callableStatement.setNClob(parameterName, reader);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>CallableStatement</code> is executed.
- * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. The
+ * <code>reader</code> must contain the number of characters specified by length
+ * otherwise a <code>SQLException</code> will be generated when the
+ * <code>CallableStatement</code> is executed. This method differs from the
+ * <code>setCharacterStream (int, Reader, int)</code> method because it informs
+ * the driver that the parameter value should be sent to the server as a
+ * <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used,
+ * the driver may have to do extra work to determine whether the parameter data
+ * should be send to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
*
* @param parameterName the name of the parameter to be set
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the length specified is less than zero;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if the length specified is less than zero; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; if a database access error occurs or this
+ * method is called on a closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
callableStatement.setNClob(parameterName, reader, length);
}
/**
- * Sets the designated parameter to the given <code>String</code> object.
- * The driver converts this to a SQL <code>NCHAR</code> or
- * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
+ * Sets the designated parameter to the given <code>String</code> object. The
+ * driver converts this to a SQL <code>NCHAR</code> or <code>NVARCHAR</code> or
+ * <code>LONGNVARCHAR</code>
*
* @param parameterName the name of the parameter to be set
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if the driver does not support national character sets; if the
+ * driver can detect that a data conversion error could occur; if a database
+ * access error occurs or this method is called on a closed
+ * <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNString(String parameterName, String value) throws SQLException {
callableStatement.setNString(parameterName, value);
}
/**
- * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
- * driver converts this to a SQL <code>ROWID</code> when it sends it to the
- * database.
+ * Sets the designated parameter to the given <code>java.sql.RowId</code>
+ * object. The driver converts this to a SQL <code>ROWID</code> when it sends it
+ * to the database.
*
* @param parameterName the name of the parameter
- * @param x the parameter value
+ * @param x the parameter value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs or
- * this method is called on a closed <code>CallableStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs or this method is called on a
+ * closed <code>CallableStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setRowId(String parameterName, RowId x) throws SQLException {
callableStatement.setRowId(parameterName, x);
}
/**
- * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
- * <code>SQL XML</code> value when it sends it to the database.
+ * Sets the designated parameter to the given <code>java.sql.SQLXML</code>
+ * object. The driver converts this to an <code>SQL XML</code> value when it
+ * sends it to the database.
*
* @param parameterName the name of the parameter
- * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
+ * @param xmlObject a <code>SQLXML</code> object that maps an
+ * <code>SQL XML</code> value
* @throws SQLException if parameterName does not correspond to a named
- * parameter; if a database access error occurs;
- * this method is called on a closed <code>CallableStatement</code> or
- * the <code>java.xml.transform.Result</code>,
- * <code>Writer</code> or <code>OutputStream</code> has not been closed for the <code>SQLXML</code> object
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * parameter; if a database access error occurs; this method is called on a
+ * closed <code>CallableStatement</code> or the
+ * <code>java.xml.transform.Result</code>, <code>Writer</code> or
+ * <code>OutputStream</code> has not been closed for the <code>SQLXML</code>
+ * object
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
callableStatement.setSQLXML(parameterName, xmlObject);
}
/**
- * Sets the designated parameter to the given input stream.
- * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * Sets the designated parameter to the given input stream. When a very large
+ * ASCII value is input to a <code>LONGVARCHAR</code> parameter, it may be more
+ * practical to send it via a <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setAsciiStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setAsciiStream</code> which takes
+ * a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the Java input stream that contains the ASCII parameter value
+ * @param x the Java input stream that contains the ASCII parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
callableStatement.setAsciiStream(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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * 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</code> parameter, it may be more practical to send it via a
+ * <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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
+ * @param x the Java input stream that contains the ASCII parameter value
+ * @param length the number of bytes in the stream
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
* @since 1.6
*/
+ @Override
public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
callableStatement.setAsciiStream(parameterIndex, x, length);
}
/**
- * Sets the designated parameter to the given input stream.
- * When a very large binary value is input to a <code>LONGVARBINARY</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the
- * stream as needed until end-of-file is reached.
+ * Sets the designated parameter to the given input stream. When a very large
+ * binary value is input to a <code>LONGVARBINARY</code> parameter, it may be
+ * more practical to send it via a <code>java.io.InputStream</code> object. The
+ * data will be read from the stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setBinaryStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setBinaryStream</code> which
+ * takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the java input stream which contains the binary parameter value
+ * @param x the java input stream which contains the binary parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
callableStatement.setBinaryStream(parameterIndex, x);
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the
+ * 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</code> parameter, it may be more practical to send it via
+ * a <code>java.io.InputStream</code> object. The data will be read from the
* stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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
+ * @param x the java input stream which contains the binary parameter value
+ * @param length the number of bytes in the stream
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
* @since 1.6
*/
+ @Override
public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
callableStatement.setBinaryStream(parameterIndex, x, length);
}
/**
- * Sets the designated parameter to a <code>InputStream</code> object.
- * This method differs from the <code>setBinaryStream (int, InputStream)</code>
- * method because it informs the driver that the parameter value should be
- * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
- * the driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
+ * Sets the designated parameter to a <code>InputStream</code> object. This
+ * method differs from the <code>setBinaryStream (int, InputStream)</code>
+ * method because it informs the driver that the parameter value should be sent
+ * to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code>
+ * method is used, the driver may have to do extra work to determine whether the
+ * parameter data should be sent to the server as a <code>LONGVARBINARY</code>
+ * or a <code>BLOB</code>
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setBlob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setBlob</code> which takes a
+ * length parameter.
*
- * @param parameterIndex index of the first parameter is 1,
- * the second is 2, ...
- * @param inputStream An object that contains the data to set the parameter
- * value to.
+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
+ * @param inputStream An object that contains the data to set the parameter
+ * value to.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code> or
- * if parameterIndex does not correspond
- * to a parameter marker in the SQL statement,
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code> or if parameterIndex
+ * does not correspond to a parameter marker in the SQL statement,
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
callableStatement.setBlob(parameterIndex, inputStream);
}
/**
- * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>PreparedStatement</code> is executed.
- * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
- * method because it informs the driver that the parameter value should be
- * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
- * the driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
+ * Sets the designated parameter to a <code>InputStream</code> object. The
+ * inputstream must contain the number of characters specified by length
+ * otherwise a <code>SQLException</code> will be generated when the
+ * <code>PreparedStatement</code> is executed. This method differs from the
+ * <code>setBinaryStream (int, InputStream, int)</code> method because it
+ * informs the driver that the parameter value should be sent to the server as a
+ * <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, the
+ * driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGVARBINARY</code> or a
+ * <code>BLOB</code>
*
- * @param parameterIndex index of the first parameter is 1,
- * the second is 2, ...
- * @param inputStream An object that contains the data to set the parameter
- * value to.
- * @param length the number of bytes in the parameter data.
+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
+ * @param inputStream An object that contains the data to set the parameter
+ * value to.
+ * @param length the number of bytes in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code>;
- * if the length specified
- * is less than zero or if the number of bytes in the inputstream does not match
- * the specfied length.
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code>; if the length specified
+ * is less than zero or if the number of bytes in the inputstream does not match
+ * the specfied length.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
callableStatement.setBlob(parameterIndex, inputStream, length);
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object. When a
+ * very large UNICODE value is input to a <code>LONGVARCHAR</code> parameter, it
+ * may be more practical to send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setCharacterStream</code> which
+ * takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param reader the <code>java.io.Reader</code> object that contains the
- * Unicode data
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * Unicode data
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
callableStatement.setCharacterStream(parameterIndex, reader);
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object, which
+ * is the given number of characters long. When a very large UNICODE value is
+ * input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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</code> object that contains the
- * Unicode data
- * @param length the number of characters in the stream
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * Unicode data
+ * @param length the number of characters in the stream
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
* @since 1.6
*/
+ @Override
public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
callableStatement.setCharacterStream(parameterIndex, reader, length);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be sent to the server as a <code>LONGVARCHAR</code> or a
+ * <code>CLOB</code>
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setClob</code> which takes a
+ * length parameter.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs; this method is called on
- * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
- * marker in the SQL statement
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code>or if parameterIndex does
+ * not correspond to a parameter marker in the SQL statement
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(int parameterIndex, Reader reader) throws SQLException {
callableStatement.setClob(parameterIndex, reader);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>PreparedStatement</code> is executed.
- * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. The reader
+ * must contain the number of characters specified by length otherwise a
+ * <code>SQLException</code> will be generated when the
+ * <code>PreparedStatement</code> is executed. This method differs from the
+ * <code>setCharacterStream (int, Reader, int)</code> method because it informs
+ * the driver that the parameter value should be sent to the server as a
+ * <code>CLOB</code>. When the <code>setCharacterStream</code> method is used,
+ * the driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGVARCHAR</code> or a
+ * <code>CLOB</code>
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs; this method is called on
- * a closed <code>PreparedStatement</code> or if the length specified is less than zero.
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code> or if the length
+ * specified is less than zero.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
callableStatement.setClob(parameterIndex, reader, length);
}
/**
* Sets the designated parameter to a <code>Reader</code> object. The
- * <code>Reader</code> reads the data till end-of-file is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
+ * <code>Reader</code> reads the data till end-of-file is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNCharacterStream</code> which
+ * takes a length parameter.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
callableStatement.setNCharacterStream(parameterIndex, value);
}
/**
* Sets the designated parameter to a <code>Reader</code> object. The
- * <code>Reader</code> reads the data till end-of-file is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
+ * <code>Reader</code> reads the data till end-of-file is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
- * @param length the number of characters in the parameter data.
+ * @param value the parameter value
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
callableStatement.setNCharacterStream(parameterIndex, value, length);
}
/**
- * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to a
- * SQL <code>NCLOB</code> value when it sends it to the database.
+ * Sets the designated parameter to a <code>java.sql.NClob</code> object. The
+ * driver converts this to a SQL <code>NCLOB</code> value when it sends it to
+ * the database.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(int parameterIndex, NClob value) throws SQLException {
callableStatement.setNClob(parameterIndex, value);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNClob</code> which takes a length parameter.
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be sent to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNClob</code> which takes a
+ * length parameter.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement;
- * if the driver does not support national character sets;
- * if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs or this method is called on a closed
+ * <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(int parameterIndex, Reader reader) throws SQLException {
callableStatement.setNClob(parameterIndex, reader);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>PreparedStatement</code> is executed.
- * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. The reader
+ * must contain the number of characters specified by length otherwise a
+ * <code>SQLException</code> will be generated when the
+ * <code>PreparedStatement</code> is executed. This method differs from the
+ * <code>setCharacterStream (int, Reader, int)</code> method because it informs
+ * the driver that the parameter value should be sent to the server as a
+ * <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used,
+ * the driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the length specified is less than zero;
- * if the driver does not support national character sets;
- * if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the length specified is less than zero; if
+ * the driver does not support national character sets; if the driver can detect
+ * that a data conversion error could occur; if a database access error occurs
+ * or this method is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
callableStatement.setNClob(parameterIndex, reader, length);
}
/**
- * Sets the designated paramter to the given <code>String</code> object.
- * The driver converts this to a SQL <code>NCHAR</code> or
- * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
- * (depending on the argument's
- * size relative to the driver's limits on <code>NVARCHAR</code> values)
- * when it sends it to the database.
+ * Sets the designated paramter to the given <code>String</code> object. The
+ * driver converts this to a SQL <code>NCHAR</code> or <code>NVARCHAR</code> or
+ * <code>LONGNVARCHAR</code> value (depending on the argument's size relative to
+ * the driver's limits on <code>NVARCHAR</code> values) when it sends it to the
+ * database.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNString(int parameterIndex, String value) throws SQLException {
callableStatement.setNString(parameterIndex, value);
}
/**
- * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
- * driver converts this to a SQL <code>ROWID</code> value when it sends it
- * to the database
+ * Sets the designated parameter to the given <code>java.sql.RowId</code>
+ * object. The driver converts this to a SQL <code>ROWID</code> value when it
+ * sends it to the database
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setRowId(int parameterIndex, RowId x) throws SQLException {
callableStatement.setRowId(parameterIndex, x);
}
/**
- * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object.
- * The driver converts this to an
- * SQL <code>XML</code> value when it sends it to the database.
+ * Sets the designated parameter to the given <code>java.sql.SQLXML</code>
+ * object. The driver converts this to an SQL <code>XML</code> value when it
+ * sends it to the database.
* <p/>
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
+ * @param xmlObject a <code>SQLXML</code> object that maps an SQL
+ * <code>XML</code> value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code>
- * or the <code>java.xml.transform.Result</code>,
- * <code>Writer</code> or <code>OutputStream</code> has not been closed for
- * the <code>SQLXML</code> object
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code> or the
+ * <code>java.xml.transform.Result</code>, <code>Writer</code> or
+ * <code>OutputStream</code> has not been closed for the <code>SQLXML</code>
+ * object
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
callableStatement.setSQLXML(parameterIndex, xmlObject);
}
/**
- * Retrieves whether this <code>Statement</code> object has been closed. A <code>Statement</code> is closed if the
- * method close has been called on it, or if it is automatically closed.
+ * Retrieves whether this <code>Statement</code> object has been closed. A
+ * <code>Statement</code> is closed if the method close has been called on it,
+ * or if it is automatically closed.
*
- * @return true if this <code>Statement</code> object is closed; false if it is still open
+ * @return true if this <code>Statement</code> object is closed; false if it is
+ * still open
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public boolean isClosed() throws SQLException {
return callableStatement.isClosed();
}
/**
- * Returns a value indicating whether the <code>Statement</code>
- * is poolable or not.
+ * Returns a value indicating whether the <code>Statement</code> is poolable or
+ * not.
* <p/>
*
* @throws SQLException if this method is called on a closed
- * <code>Statement</code>
- * <p/>
- * @return <code>true</code> if the <code>Statement</code>
- * is poolable; <code>false</code> otherwise
+ * <code>Statement</code>
+ * <p/>
+ * @return <code>true</code> if the <code>Statement</code> is poolable;
+ * <code>false</code> otherwise
* <p/>
* @see java.sql.Statement#setPoolable(boolean) setPoolable(boolean)
* @since 1.6
- * <p/>
+ * <p/>
*/
+ @Override
public boolean isPoolable() throws SQLException {
return callableStatement.isPoolable();
}
/**
- * Requests that a <code>Statement</code> be pooled or not pooled. The value
- * specified is a hint to the statement pool implementation indicating
- * whether the applicaiton wants the statement to be pooled. It is up to
- * the statement pool manager as to whether the hint is used.
+ * Requests that a <code>Statement</code> be pooled or not pooled. The value
+ * specified is a hint to the statement pool implementation indicating whether
+ * the applicaiton wants the statement to be pooled. It is up to the statement
+ * pool manager as to whether the hint is used.
* <p/>
- * The poolable value of a statement is applicable to both internal
- * statement caches implemented by the driver and external statement caches
- * implemented by application servers and other applications.
+ * The poolable value of a statement is applicable to both internal statement
+ * caches implemented by the driver and external statement caches implemented by
+ * application servers and other applications.
* <p/>
- * By default, a <code>Statement</code> is not poolable when created, and
- * a <code>PreparedStatement</code> and <code>CallableStatement</code>
- * are poolable when created.
+ * By default, a <code>Statement</code> is not poolable when created, and a
+ * <code>PreparedStatement</code> and <code>CallableStatement</code> are
+ * poolable when created.
* <p/>
*
- * @param poolable requests that the statement be pooled if true and
- * that the statement not be pooled if false
- * <p/>
+ * @param poolable requests that the statement be pooled if true and that the
+ * statement not be pooled if false
+ * <p/>
* @throws SQLException if this method is called on a closed
- * <code>Statement</code>
- * <p/>
+ * <code>Statement</code>
+ * <p/>
* @since 1.6
*/
+ @Override
public void setPoolable(boolean poolable) throws SQLException {
callableStatement.setPoolable(poolable);
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
boolean result;
if (iface.isInstance(this)) {
@@ -1346,19 +1402,22 @@
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
T result = null;
if (iface.isInstance(this)) {
@@ -1370,15 +1429,16 @@
}
/**
- * Executes the SQL query in this <code>PreparedStatement</code> object
- * and returns the <code>ResultSet</code> object generated by the query.
+ * Executes the SQL query in this <code>PreparedStatement</code> object and
+ * returns the <code>ResultSet</code> object generated by the query.
*
- * @return a <code>ResultSet</code> object that contains the data produced by the
- * query; never <code>null</code>
- * @throws SQLException if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code> or the SQL
- * statement does not return a <code>ResultSet</code> object
+ * @return a <code>ResultSet</code> object that contains the data produced by
+ * the query; never <code>null</code>
+ * @throws SQLException if a database access error occurs; this method is called
+ * on a closed <code>PreparedStatement</code> or the SQL statement does not
+ * return a <code>ResultSet</code> object
*/
+ @Override
public java.sql.ResultSet executeQuery() throws java.sql.SQLException {
ResultSet rs = callableStatement.executeQuery();
incrementResultSetReferenceCount();
@@ -1389,17 +1449,16 @@
* Executes the given SQL statement, which returns a single
* <code>ResultSet</code> object.
*
- * @param sql an SQL statement to be sent to the database, typically a
- * static SQL <code>SELECT</code> statement
- * @return a <code>ResultSet</code> object that contains the data produced
- * by the given query; never <code>null</code>
- * @throws SQLException if a database access error occurs,
- * this method is called on a closed <code>Statement</code> or the given
- * SQL statement produces anything other than a single
- * <code>ResultSet</code> object
+ * @param sql an SQL statement to be sent to the database, typically a static
+ * SQL <code>SELECT</code> statement
+ * @return a <code>ResultSet</code> object that contains the data produced by
+ * the given query; never <code>null</code>
+ * @throws SQLException if a database access error occurs, this method is called
+ * on a closed <code>Statement</code> or the given SQL statement produces
+ * anything other than a single <code>ResultSet</code> object
*/
- public java.sql.ResultSet executeQuery(String sql) throws
- java.sql.SQLException {
+ @Override
+ public java.sql.ResultSet executeQuery(String sql) throws java.sql.SQLException {
ResultSet rs = callableStatement.executeQuery(sql);
incrementResultSetReferenceCount();
return new ResultSetWrapper40(this, rs);
@@ -1407,21 +1466,23 @@
/**
* Retrieves any auto-generated keys created as a result of executing this
- * <code>Statement</code> object. If this <code>Statement</code> object did
- * not generate any keys, an empty <code>ResultSet</code>
- * object is returned.
+ * <code>Statement</code> object. If this <code>Statement</code> object did not
+ * generate any keys, an empty <code>ResultSet</code> object is returned.
* <p/>
- * <p><B>Note:</B>If the columns which represent the auto-generated keys were not specified,
- * the JDBC driver implementation will determine the columns which best represent the auto-generated keys.
+ * <p>
+ * <B>Note:</B>If the columns which represent the auto-generated keys were not
+ * specified, the JDBC driver implementation will determine the columns which
+ * best represent the auto-generated keys.
*
* @return a <code>ResultSet</code> object containing the auto-generated key(s)
- * generated by the execution of this <code>Statement</code> object
- * @throws SQLException if a database access error occurs or
- * this method is called on a closed <code>Statement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * generated by the execution of this <code>Statement</code> object
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed <code>Statement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.4
*/
+ @Override
public java.sql.ResultSet getGeneratedKeys() throws java.sql.SQLException {
ResultSet rs = callableStatement.getGeneratedKeys();
if (rs == null)
@@ -1431,48 +1492,56 @@
}
/**
- * Retrieves the current result as a <code>ResultSet</code> object.
- * This method should be called only once per result.
+ * Retrieves the current result as a <code>ResultSet</code> object. This method
+ * should be called only once per result.
*
* @return the current result as a <code>ResultSet</code> object or
- * <code>null</code> if the result is an update count or there are no more results
- * @throws SQLException if a database access error occurs or
- * this method is called on a closed <code>Statement</code>
+ * <code>null</code> if the result is an update count or there are no more
+ * results
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed <code>Statement</code>
* @see #execute
*/
- public java.sql.ResultSet getResultSet() throws java.sql.SQLException {
+ @Override
+ public ResultSet getResultSet() throws java.sql.SQLException {
ResultSet rs = callableStatement.getResultSet();
- if (rs == null)
+ if (rs == null) {
return null;
+ }
+
incrementResultSetReferenceCount();
return new ResultSetWrapper40(this, rs);
}
+ @Override
+ @SuppressWarnings("unchecked")
public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- Class<?>[] valueTypes = new Class<?>[]{Integer.TYPE, Class.class};
- try {
- return (T) executor.invokeMethod(jdbcStatement, "getObject",
- valueTypes, parameterIndex, type);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_get_object", ex);
- throw new SQLException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ Class<?>[] valueTypes = new Class<?>[] { Integer.TYPE, Class.class };
+ try {
+ return (T) executor.invokeMethod(jdbcStatement, "getObject", valueTypes, parameterIndex, type);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_get_object", ex);
+ throw new SQLException(ex);
+ }
}
+ @Override
+ @SuppressWarnings("unchecked")
public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- Class<?>[] valueTypes = new Class<?>[]{String.class, Class.class};
- try {
- return (T) executor.invokeMethod(jdbcStatement, "getObject",
- valueTypes, parameterName, type);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_get_object", ex);
- throw new SQLException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ Class<?>[] valueTypes = new Class<?>[] { String.class, Class.class };
+ try {
+ return (T) executor.invokeMethod(jdbcStatement, "getObject", valueTypes, parameterName, type);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_get_object", ex);
+ throw new SQLException(ex);
+ }
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionHolder40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionHolder40.java
index 567683c..6ceaa78 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionHolder40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionHolder40.java
@@ -16,56 +16,69 @@
package com.sun.gjc.spi.jdbc40;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
-import com.sun.gjc.spi.ManagedConnectionImpl;
-import com.sun.gjc.spi.base.ConnectionHolder;
+import static com.sun.gjc.common.DataSourceObjectBuilder.isJDBC41;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.SEVERE;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
-import java.sql.*;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.NClob;
+import java.sql.ResultSet;
+import java.sql.SQLClientInfoException;
+import java.sql.SQLException;
+import java.sql.SQLXML;
+import java.sql.Struct;
import java.util.Properties;
import java.util.concurrent.Executor;
-import java.util.logging.Level;
-import jakarta.resource.ResourceException;
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
+import com.sun.gjc.spi.ManagedConnectionImpl;
+import com.sun.gjc.spi.base.ConnectionHolder;
+
+import jakarta.resource.ResourceException;
+import jakarta.resource.spi.ConnectionRequestInfo;
/**
- * Holds the java.sql.Connection object, which is to be
- * passed to the application program.
+ * Holds the java.sql.Connection object, which is to be passed to the
+ * application program.
*
* @author Jagadish Ramu
* @version 1.0, 25-Aug-2006
*/
public class ConnectionHolder40 extends ConnectionHolder {
+ protected final static StringManager localStrings = StringManager.getManager(ManagedConnectionFactoryImpl.class);
protected Properties defaultClientInfo;
- protected final static StringManager localStrings =
- StringManager.getManager(ManagedConnectionFactoryImpl.class);
protected boolean jdbc30Connection;
/**
* Connection wrapper given to application program
*
- * @param con Connection that is wrapped
- * @param mc ManagedConnection
+ * @param con Connection that is wrapped
+ * @param mc ManagedConnection
* @param cxRequestInfo Connection Request Information
*/
- public ConnectionHolder40(Connection con, ManagedConnectionImpl mc,
- jakarta.resource.spi.ConnectionRequestInfo cxRequestInfo,
- boolean jdbc30Connection) {
+ public ConnectionHolder40(Connection con, ManagedConnectionImpl mc, ConnectionRequestInfo cxRequestInfo, boolean jdbc30Connection) {
super(con, mc, cxRequestInfo);
this.jdbc30Connection = jdbc30Connection;
- if (!jdbc30Connection)
+ if (!jdbc30Connection) {
init();
+ }
}
/**
* cache the default client info which can will set back during close()<br>
- * as this connection may be re-used by connection pool of application server<br>
+ * as this connection may be re-used by connection pool of application
+ * server<br>
*/
protected void init() {
try {
@@ -73,180 +86,178 @@
defaultClientInfo = getClientInfo();
}
} catch (Throwable e) {
- _logger.log(Level.INFO, "jdbc.unable_to_get_client_info", e.getMessage());
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST, "jdbc.unable_to_get_client_info", e);
- }
+ _logger.log(INFO, "jdbc.unable_to_get_client_info", e.getMessage());
+ _logger.log(FINEST, "jdbc.unable_to_get_client_info", e);
}
}
/**
- * Constructs an object that implements the <code>Clob</code> interface. The object
- * returned initially contains no data. The <code>setAsciiStream</code>,
- * <code>setCharacterStream</code> and <code>setString</code> methods of
- * the <code>Clob</code> interface may be used to add data to the <code>Clob</code>.
+ * Constructs an object that implements the <code>Clob</code> interface. The
+ * object returned initially contains no data. The <code>setAsciiStream</code>,
+ * <code>setCharacterStream</code> and <code>setString</code> methods of the
+ * <code>Clob</code> interface may be used to add data to the <code>Clob</code>.
*
* @return An object that implements the <code>Clob</code> interface
* @throws java.sql.SQLException if an object that implements the
- * <code>Clob</code> interface can not be constructed, this method is
- * called on a closed connection or a database access error occurs.
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this data type
+ * <code>Clob</code> interface can not be constructed, this method is called on
+ * a closed connection or a database access error occurs.
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this data type
* @since 1.6
*/
+ @Override
public Clob createClob() throws SQLException {
checkValidity();
jdbcPreInvoke();
- return con.createClob();
+ return connection.createClob();
}
/**
- * Constructs an object that implements the <code>Blob</code> interface. The object
- * returned initially contains no data. The <code>setBinaryStream</code> and
- * <code>setBytes</code> methods of the <code>Blob</code> interface may be used to add data to
- * the <code>Blob</code>.
+ * Constructs an object that implements the <code>Blob</code> interface. The
+ * object returned initially contains no data. The <code>setBinaryStream</code>
+ * and <code>setBytes</code> methods of the <code>Blob</code> interface may be
+ * used to add data to the <code>Blob</code>.
*
* @return An object that implements the <code>Blob</code> interface
* @throws java.sql.SQLException if an object that implements the
- * <code>Blob</code> interface can not be constructed, this method is
- * called on a closed connection or a database access error occurs.
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this data type
+ * <code>Blob</code> interface can not be constructed, this method is called on
+ * a closed connection or a database access error occurs.
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this data type
* @since 1.6
*/
+ @Override
public Blob createBlob() throws SQLException {
checkValidity();
jdbcPreInvoke();
- return con.createBlob();
+ return connection.createBlob();
}
/**
- * Constructs an object that implements the <code>NClob</code> interface. The object
- * returned initially contains no data. The <code>setAsciiStream</code>,
- * <code>setCharacterStream</code> and <code>setString</code> methods of the <code>NClob</code> interface may
- * be used to add data to the <code>NClob</code>.
+ * Constructs an object that implements the <code>NClob</code> interface. The
+ * object returned initially contains no data. The <code>setAsciiStream</code>,
+ * <code>setCharacterStream</code> and <code>setString</code> methods of the
+ * <code>NClob</code> interface may be used to add data to the
+ * <code>NClob</code>.
*
* @return An object that implements the <code>NClob</code> interface
* @throws java.sql.SQLException if an object that implements the
- * <code>NClob</code> interface can not be constructed, this method is
- * called on a closed connection or a database access error occurs.
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this data type
+ * <code>NClob</code> interface can not be constructed, this method is called on
+ * a closed connection or a database access error occurs.
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this data type
* @since 1.6
*/
+ @Override
public NClob createNClob() throws SQLException {
checkValidity();
jdbcPreInvoke();
- return con.createNClob();
+ return connection.createNClob();
}
/**
- * Constructs an object that implements the <code>SQLXML</code> interface. The object
- * returned initially contains no data. The <code>createXmlStreamWriter</code> object and
- * <code>setString</code> method of the <code>SQLXML</code> interface may be used to add data to the <code>SQLXML</code>
- * object.
+ * Constructs an object that implements the <code>SQLXML</code> interface. The
+ * object returned initially contains no data. The
+ * <code>createXmlStreamWriter</code> object and <code>setString</code> method
+ * of the <code>SQLXML</code> interface may be used to add data to the
+ * <code>SQLXML</code> object.
*
* @return An object that implements the <code>SQLXML</code> interface
- * @throws java.sql.SQLException if an object that implements the <code>SQLXML</code> interface can not
- * be constructed, this method is
- * called on a closed connection or a database access error occurs.
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this data type
+ * @throws java.sql.SQLException if an object that implements the
+ * <code>SQLXML</code> interface can not be constructed, this method is called
+ * on a closed connection or a database access error occurs.
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this data type
* @since 1.6
*/
+ @Override
public SQLXML createSQLXML() throws SQLException {
checkValidity();
jdbcPreInvoke();
- return con.createSQLXML();
+ return connection.createSQLXML();
}
/**
- * Returns true if the connection has not been closed and is still valid.
- * The driver shall submit a query on the connection or use some other
- * mechanism that positively verifies the connection is still valid when
- * this method is called.
+ * Returns true if the connection has not been closed and is still valid. The
+ * driver shall submit a query on the connection or use some other mechanism
+ * that positively verifies the connection is still valid when this method is
+ * called.
* <p/>
* The query submitted by the driver to validate the connection shall be
* executed in the context of the current transaction.
*
- * @param timeout - The time in seconds to wait for the database operation
- * used to validate the connection to complete. If
- * the timeout period expires before the operation
- * completes, this method returns false. A value of
- * 0 indicates a timeout is not applied to the
- * database operation.
- * <p/>
+ * @param timeout - The time in seconds to wait for the database operation used
+ * to validate the connection to complete. If the timeout period expires before
+ * the operation completes, this method returns false. A value of 0 indicates a
+ * timeout is not applied to the database operation.
+ * <p/>
* @return true if the connection is valid, false otherwise
* @throws java.sql.SQLException if the value supplied for <code>timeout</code>
- * is less then 0
+ * is less then 0
* @see java.sql.DatabaseMetaData#getClientInfoProperties
* @since 1.6
- * <p/>
+ * <p/>
*/
+ @Override
public boolean isValid(int timeout) throws SQLException {
checkValidity();
- return con.isValid(timeout);
+ return connection.isValid(timeout);
}
/**
- * Sets the value of the client info property specified by name to the
- * value specified by value.
+ * Sets the value of the client info property specified by name to the value
+ * specified by value.
* <p/>
- * Applications may use the <code>DatabaseMetaData.getClientInfoProperties</code>
- * method to determine the client info properties supported by the driver
- * and the maximum length that may be specified for each property.
+ * Applications may use the
+ * <code>DatabaseMetaData.getClientInfoProperties</code> method to determine the
+ * client info properties supported by the driver and the maximum length that
+ * may be specified for each property.
* <p/>
- * The driver stores the value specified in a suitable location in the
- * database. For example in a special register, session parameter, or
- * system table column. For efficiency the driver may defer setting the
- * value in the database until the next time a statement is executed or
- * prepared. Other than storing the client information in the appropriate
- * place in the database, these methods shall not alter the behavior of
- * the connection in anyway. The values supplied to these methods are
- * used for accounting, diagnostics and debugging purposes only.
+ * The driver stores the value specified in a suitable location in the database.
+ * For example in a special register, session parameter, or system table column.
+ * For efficiency the driver may defer setting the value in the database until
+ * the next time a statement is executed or prepared. Other than storing the
+ * client information in the appropriate place in the database, these methods
+ * shall not alter the behavior of the connection in anyway. The values supplied
+ * to these methods are used for accounting, diagnostics and debugging purposes
+ * only.
* <p/>
- * The driver shall generate a warning if the client info name specified
- * is not recognized by the driver.
+ * The driver shall generate a warning if the client info name specified is not
+ * recognized by the driver.
* <p/>
- * If the value specified to this method is greater than the maximum
- * length for the property the driver may either truncate the value and
- * generate a warning or generate a <code>SQLClientInfoException</code>. If the driver
- * generates a <code>SQLClientInfoException</code>, the value specified was not set on the
+ * If the value specified to this method is greater than the maximum length for
+ * the property the driver may either truncate the value and generate a warning
+ * or generate a <code>SQLClientInfoException</code>. If the driver generates a
+ * <code>SQLClientInfoException</code>, the value specified was not set on the
* connection.
* <p/>
- * The following are standard client info properties. Drivers are not
- * required to support these properties however if the driver supports a
- * client info property that can be described by one of the standard
- * properties, the standard property name should be used.
+ * The following are standard client info properties. Drivers are not required
+ * to support these properties however if the driver supports a client info
+ * property that can be described by one of the standard properties, the
+ * standard property name should be used.
* <p/>
* <ul>
- * <li>ApplicationName - The name of the application currently utilizing
- * the connection</li>
- * <li>ClientUser - The name of the user that the application using
- * the connection is performing work for. This may
- * not be the same as the user name that was used
- * in establishing the connection.</li>
- * <li>ClientHostname - The hostname of the computer the application
- * using the connection is running on.</li>
+ * <li>ApplicationName - The name of the application currently utilizing the
+ * connection</li>
+ * <li>ClientUser - The name of the user that the application using the
+ * connection is performing work for. This may not be the same as the user name
+ * that was used in establishing the connection.</li>
+ * <li>ClientHostname - The hostname of the computer the application using the
+ * connection is running on.</li>
* </ul>
* <p/>
*
* @param name The name of the client info property to set
- * @param value The value to set the client info property to. If the
- * value is null, the current value of the specified
- * property is cleared.
- * <p/>
- * @throws java.sql.SQLClientInfoException
- * if the database server returns an error while
- * setting the client info value on the database server or this method
- * is called on a closed connection
- * <p/>
+ * @param value The value to set the client info property to. If the value is
+ * null, the current value of the specified property is cleared.
+ * <p/>
+ * @throws java.sql.SQLClientInfoException if the database server returns an
+ * error while setting the client info value on the database server or this
+ * method is called on a closed connection
+ * <p/>
* @since 1.6
*/
+ @Override
public void setClientInfo(String name, String value) throws SQLClientInfoException {
try {
checkValidity();
@@ -255,40 +266,40 @@
sce.setStackTrace(sqe.getStackTrace());
throw sce;
}
- con.setClientInfo(name, value);
+ connection.setClientInfo(name, value);
}
/**
- * Sets the value of the connection's client info properties. The
- * <code>Properties</code> object contains the names and values of the client info
- * properties to be set. The set of client info properties contained in
- * the properties list replaces the current set of client info properties
- * on the connection. If a property that is currently set on the
- * connection is not present in the properties list, that property is
- * cleared. Specifying an empty properties list will clear all of the
- * properties on the connection. See <code>setClientInfo (String, String)</code> for
- * more information.
+ * Sets the value of the connection's client info properties. The
+ * <code>Properties</code> object contains the names and values of the client
+ * info properties to be set. The set of client info properties contained in the
+ * properties list replaces the current set of client info properties on the
+ * connection. If a property that is currently set on the connection is not
+ * present in the properties list, that property is cleared. Specifying an empty
+ * properties list will clear all of the properties on the connection. See
+ * <code>setClientInfo (String, String)</code> for more information.
* <p/>
* If an error occurs in setting any of the client info properties, a
- * <code>SQLClientInfoException</code> is thrown. The <code>SQLClientInfoException</code>
- * contains information indicating which client info properties were not set.
- * The state of the client information is unknown because
- * some databases do not allow multiple client info properties to be set
- * atomically. For those databases, one or more properties may have been
- * set before the error occurred.
+ * <code>SQLClientInfoException</code> is thrown. The
+ * <code>SQLClientInfoException</code> contains information indicating which
+ * client info properties were not set. The state of the client information is
+ * unknown because some databases do not allow multiple client info properties
+ * to be set atomically. For those databases, one or more properties may have
+ * been set before the error occurred.
* <p/>
*
* @param properties the list of client info properties to set
- * <p/>
- * @throws java.sql.SQLClientInfoException
- * if the database server returns an error while
- * setting the clientInfo values on the database server or this method
- * is called on a closed connection
- * <p/>
- * @see java.sql.Connection#setClientInfo(String,String) setClientInfo(String, String)
+ * <p/>
+ * @throws java.sql.SQLClientInfoException if the database server returns an
+ * error while setting the clientInfo values on the database server or this
+ * method is called on a closed connection
+ * <p/>
+ * @see java.sql.Connection#setClientInfo(String,String) setClientInfo(String,
+ * String)
* @since 1.6
- * <p/>
+ * <p/>
*/
+ @Override
public void setClientInfo(Properties properties) throws SQLClientInfoException {
try {
checkValidity();
@@ -297,73 +308,76 @@
sce.setStackTrace(sqe.getStackTrace());
throw sce;
}
- con.setClientInfo(properties);
+ connection.setClientInfo(properties);
}
/**
- * Returns the value of the client info property specified by name. This
- * method may return null if the specified client info property has not
- * been set and does not have a default value. This method will also
- * return null if the specified client info property name is not supported
- * by the driver.
+ * Returns the value of the client info property specified by name. This method
+ * may return null if the specified client info property has not been set and
+ * does not have a default value. This method will also return null if the
+ * specified client info property name is not supported by the driver.
* <p/>
- * Applications may use the <code>DatabaseMetaData.getClientInfoProperties</code>
- * method to determine the client info properties supported by the driver.
+ * Applications may use the
+ * <code>DatabaseMetaData.getClientInfoProperties</code> method to determine the
+ * client info properties supported by the driver.
* <p/>
*
* @param name The name of the client info property to retrieve
- * <p/>
+ * <p/>
* @return The value of the client info property specified
- * <p/>
+ * <p/>
* @throws java.sql.SQLException if the database server returns an error when
- * fetching the client info value from the database
- * or this method is called on a closed connection
- * <p/>
+ * fetching the client info value from the database or this method is called on
+ * a closed connection
+ * <p/>
* @see java.sql.DatabaseMetaData#getClientInfoProperties
* @since 1.6
- * <p/>
+ * <p/>
*/
+ @Override
public String getClientInfo(String name) throws SQLException {
checkValidity();
- return con.getClientInfo(name);
+ return connection.getClientInfo(name);
}
/**
* Returns a list containing the name and current value of each client info
- * property supported by the driver. The value of a client info property
- * may be null if the property has not been set and does not have a
- * default value.
+ * property supported by the driver. The value of a client info property may be
+ * null if the property has not been set and does not have a default value.
* <p/>
*
- * @return A <code>Properties</code> object that contains the name and current value of
- * each of the client info properties supported by the driver.
- * <p/>
+ * @return A <code>Properties</code> object that contains the name and current
+ * value of each of the client info properties supported by the driver.
+ * <p/>
* @throws java.sql.SQLException if the database server returns an error when
- * fetching the client info values from the database
- * or this method is called on a closed connection
- * <p/>
+ * fetching the client info values from the database or this method is called on
+ * a closed connection
+ * <p/>
* @since 1.6
*/
+ @Override
public Properties getClientInfo() throws SQLException {
checkValidity();
- return con.getClientInfo();
+ return connection.getClientInfo();
}
/**
- * Returns true if the client info properties are supported.
- * The application server calls the <code>getClientInfo</code> method and the <code>setClientInfo</code> method
- * only if the driver supports the client info properties.
- * The <code>DatabaseMetaData#getClientInfoProperties</code> method is used to determine
- * whether the driver supports the client info properties or not.
- * Note that the <code>DatabaseMetaData</code> will be cached by <code>ManagedConnection</code>.
+ * Returns true if the client info properties are supported. The application
+ * server calls the <code>getClientInfo</code> method and the
+ * <code>setClientInfo</code> method only if the driver supports the client info
+ * properties. The <code>DatabaseMetaData#getClientInfoProperties</code> method
+ * is used to determine whether the driver supports the client info properties
+ * or not. Note that the <code>DatabaseMetaData</code> will be cached by
+ * <code>ManagedConnection</code>.
* <p/>
*
* @return true if the client info properties are supported, false otherwise
*
- * @throws jakarta.resource.ResourceException if the access to connection is failed.
+ * @throws jakarta.resource.ResourceException if the access to connection is
+ * failed.
*
- * @throws java.sql.SQLException if the database server returns an error when retrieving
- * a list of the client info properties.
+ * @throws java.sql.SQLException if the database server returns an error when
+ * retrieving a list of the client info properties.
*
* @see java.sql.DatabaseMetaData#getClientInfoProperties
* @since 1.6
@@ -380,10 +394,10 @@
return isSupportClientInfo;
} finally {
try {
- rs.close();
- } catch(SQLException ex) {
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST, "jdbc.unable_to_get_client_info", ex);
+ rs.close();
+ } catch (SQLException ex) {
+ if (_logger.isLoggable(FINEST)) {
+ _logger.log(FINEST, "jdbc.unable_to_get_client_info", ex);
}
return false;
}
@@ -394,100 +408,113 @@
/**
* Factory method for creating Array objects.
*
- * @param typeName the SQL name of the type the elements of the array map to. The typeName is a
- * database-specific name which may be the name of a built-in type, a user-defined type or a standard SQL type supported by this database. This
- * is the value returned by <code>Array.getBaseTypeName</code>
+ * @param typeName the SQL name of the type the elements of the array map to.
+ * The typeName is a database-specific name which may be the name of a built-in
+ * type, a user-defined type or a standard SQL type supported by this database.
+ * This is the value returned by <code>Array.getBaseTypeName</code>
* @param elements the elements that populate the returned object
* @return an Array object whose elements map to the specified SQL type
- * @throws java.sql.SQLException if a database error occurs, the typeName is null or this method is called on a closed connection
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support this data type
+ * @throws java.sql.SQLException if a database error occurs, the typeName is
+ * null or this method is called on a closed connection
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this data type
* @since 1.6
*/
+ @Override
public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
checkValidity();
jdbcPreInvoke();
- return con.createArrayOf(typeName, elements);
+ return connection.createArrayOf(typeName, elements);
}
/**
* Factory method for creating Struct objects.
*
- * @param typeName the SQL type name of the SQL structured type that this <code>Struct</code>
- * object maps to. The typeName is the name of a user-defined type that
- * has been defined for this database. It is the value returned by
- * <code>Struct.getSQLTypeName</code>.
+ * @param typeName the SQL type name of the SQL structured type that this
+ * <code>Struct</code> object maps to. The typeName is the name of a
+ * user-defined type that has been defined for this database. It is the value
+ * returned by <code>Struct.getSQLTypeName</code>.
* @param attributes the attributes that populate the returned object
- * @return a Struct object that maps to the given SQL type and is populated with the given attributes
- * @throws java.sql.SQLException if a database error occurs, the typeName is null or this method is called on a closed connection
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support this data type
+ * @return a Struct object that maps to the given SQL type and is populated with
+ * the given attributes
+ * @throws java.sql.SQLException if a database error occurs, the typeName is
+ * null or this method is called on a closed connection
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this data type
* @since 1.6
*/
+ @Override
public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
checkValidity();
jdbcPreInvoke();
- return con.createStruct(typeName, attributes);
+ return connection.createStruct(typeName, attributes);
}
/**
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
checkValidity();
- T result = null;
- if (iface.isInstance(this)) { //if iface is "java.sql.Connection"
- result = iface.cast(this);
- } else if (iface.isInstance(con)) {
- //if iface is not "java.sql.Connection" & implemented by native Connection
- Class<T> listIntf[] = new Class[]{iface};
- result = getProxyObject(con, listIntf);
- } else {
- //probably a proxy, delegating to native connection
- result = con.unwrap(iface);
- if (Connection.class.isInstance(result)) {
- // rare case : returned object implements both iface & java.sql.Connection
- Class<T> listIntf[] = new Class[]{iface, Connection.class};
- result = getProxyObject(result, listIntf);
- }
+
+ if (iface.isInstance(this)) { // if iface is "java.sql.Connection"
+ return iface.cast(this);
}
+
+ if (iface.isInstance(connection)) {
+ // If iface is not "java.sql.Connection" & implemented by native Connection
+ @SuppressWarnings("unchecked")
+ Class<T>[] listIntf = new Class[] { iface };
+ return getProxyObject(connection, listIntf);
+ }
+
+ // Probably a proxy, delegating to native connection
+ T result = connection.unwrap(iface);
+ if (Connection.class.isInstance(result)) {
+ // rare case : returned object implements both iface & java.sql.Connection
+ @SuppressWarnings("unchecked")
+ Class<T> listIntf[] = new Class[] { iface, Connection.class };
+ result = getProxyObject(result, listIntf);
+ }
+
return result;
}
/**
* @param actualObject Object from jdbc vendor connection's unwrap
- * @param ifaces Interfaces for which proxy is needed
+ * @param ifaces Interfaces for which proxy is needed
* @return Proxy class implmenting the interfaces
* @throws SQLException
*/
+ @SuppressWarnings("unchecked")
private <T> T getProxyObject(final Object actualObject, Class<T>[] ifaces) throws SQLException {
- T result;
- InvocationHandler ih;
+ InvocationHandler invocationHandler;
try {
- ih = new InvocationHandler() {
- public Object invoke(Object proxy, Method method, Object[] args) throws SQLException,
- IllegalAccessException, InvocationTargetException {
+ invocationHandler = new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws SQLException, IllegalAccessException, InvocationTargetException {
+
// When close() is called on proxy object, call close() on resource adapter's
// Connection Holder instead of physical connection.
- if (method.getName().equals("close")
- && method.getParameterTypes().length == 0) {
- if (_logger.isLoggable(Level.FINE)) {
- String msg = localStrings.getString("jdbc.close_called_on_proxy_object", actualObject);
- _logger.log(Level.FINE, msg);
+ if (method.getName().equals("close") && method.getParameterTypes().length == 0) {
+ if (_logger.isLoggable(FINE)) {
+ _logger.log(FINE, localStrings.getString("jdbc.close_called_on_proxy_object", actualObject));
}
ConnectionHolder40.this.close();
return null;
@@ -500,34 +527,37 @@
} catch (Exception e) {
throw new SQLException(e.fillInStackTrace());
}
- result = (T) Proxy.newProxyInstance(actualObject.getClass().getClassLoader(), ifaces, ih);
- return result;
+
+ return (T) Proxy.newProxyInstance(actualObject.getClass().getClassLoader(), ifaces, invocationHandler);
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
checkValidity();
- boolean result;
if (iface.isInstance(this)) {
- result = true;
- } else {
- result = con.isWrapperFor(iface);
+ return true;
}
- return result;
+
+ return connection.isWrapperFor(iface);
}
/**
@@ -536,13 +566,13 @@
*
* @throws SQLException In case of a database error.
*/
+ @Override
public void close() throws SQLException {
if (isClosed) {
- if (_logger.isLoggable(Level.FINE)) {
- _logger.log(Level.FINE, "jdbc.duplicate_close_connection", this);
- }
+ _logger.log(FINE, "jdbc.duplicate_close_connection", this);
return;
}
+
if (!jdbc30Connection) {
try {
checkValidity();
@@ -554,91 +584,104 @@
}
}
} catch (Throwable e) {
- _logger.log(Level.INFO, "jdbc.unable_to_set_client_info", e.getMessage());
- if(_logger.isLoggable(Level.FINEST)) {
- _logger.log(Level.FINEST, "jdbc.unable_to_set_client_info", e);
- }
+ _logger.log(INFO, "jdbc.unable_to_set_client_info", e.getMessage());
+ _logger.log(FINEST, "jdbc.unable_to_set_client_info", e);
}
}
+
super.close();
}
+ @Override
public void setSchema(String schema) throws SQLException {
- if(DataSourceObjectBuilder.isJDBC41()) {
- checkValidity();
- Class<?>[] valueTypes = new Class<?>[]{String.class};
- try {
- getMethodExecutor().invokeMethod(con, "setSchema", valueTypes, schema);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_connection_holder", ex);
- throw new SQLException(ex);
- }
- return;
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ checkValidity();
+
+ Class<?>[] valueTypes = new Class<?>[] { String.class };
+ try {
+ getMethodExecutor().invokeMethod(connection, "setSchema", valueTypes, schema);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_connection_holder", ex);
+ throw new SQLException(ex);
+ }
+
+ return;
+
}
+ @Override
public String getSchema() throws SQLException {
- if(DataSourceObjectBuilder.isJDBC41()) {
- checkValidity();
- try {
- return (String) getMethodExecutor().invokeMethod(con, "getSchema", null);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_connection_holder", ex);
- throw new SQLException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ checkValidity();
+
+ try {
+ return (String) getMethodExecutor().invokeMethod(connection, "getSchema", null);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_connection_holder", ex);
+ throw new SQLException(ex);
+ }
}
- public void setNetworkTimeout(Executor executorObj, int milliseconds)
- throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- checkValidity();
- Class<?>[] valueTypes = new Class<?>[]{Executor.class, Integer.TYPE};
- try {
- getMethodExecutor().invokeMethod(con, "setNetworkTimeout", valueTypes, executorObj, milliseconds);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_connection_holder", ex);
- throw new SQLException(ex);
- }
- return;
+ @Override
+ public void setNetworkTimeout(Executor executorObj, int milliseconds) throws SQLException {
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ checkValidity();
+
+ Class<?>[] valueTypes = new Class<?>[] { Executor.class, Integer.TYPE };
+ try {
+ getMethodExecutor().invokeMethod(connection, "setNetworkTimeout", valueTypes, executorObj, milliseconds);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_connection_holder", ex);
+ throw new SQLException(ex);
+ }
+ return;
}
+ @Override
public int getNetworkTimeout() throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- checkValidity();
- try {
- return (Integer) getMethodExecutor().invokeMethod(con, "getNetworkTimeout", null);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_connection_holder", ex);
- throw new SQLException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ checkValidity();
+
+ try {
+ return (Integer) getMethodExecutor().invokeMethod(connection, "getNetworkTimeout", null);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_connection_holder", ex);
+ throw new SQLException(ex);
+ }
}
/**
- * Abort operation to mark the connection internally as a bad connection
- * for removal and to close the connection. This ensures that at the end
- * of the transaction, the connection is destroyed. A running thread
- * holding a connection will run to completion before the connection is
- * destroyed
+ * Abort operation to mark the connection internally as a bad connection for
+ * removal and to close the connection. This ensures that at the end of the
+ * transaction, the connection is destroyed. A running thread holding a
+ * connection will run to completion before the connection is destroyed
*
* @param executor
* @throws SQLException
*/
+ @Override
public void abort(Executor executor) throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- getManagedConnection().markForRemoval(true);
- getManagedConnection().setAborted(true);
- if(!getManagedConnection().isTransactionInProgress()) {
- close();
- }
- } else {
+ if (!isJDBC41()) {
throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
+
+ getManagedConnection().markForRemoval(true);
+ getManagedConnection().setAborted(true);
+ if (!getManagedConnection().isTransactionInProgress()) {
+ close();
+ }
+
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionWrapper40.java
index 4b3619b..a337163 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ConnectionWrapper40.java
@@ -16,13 +16,24 @@
package com.sun.gjc.spi.jdbc40;
+import static java.sql.ResultSet.CONCUR_READ_ONLY;
+import static java.sql.ResultSet.TYPE_FORWARD_ONLY;
+
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+
import com.sun.gjc.spi.ManagedConnectionImpl;
import com.sun.gjc.spi.base.ConnectionWrapper;
-import java.sql.*;
+import jakarta.resource.spi.ConnectionRequestInfo;
/**
- * Wrapper class that aids to provide wrapper for the following JDBC objects : <br>
+ * Wrapper class that aids to provide wrapper for the following JDBC objects :
+ * <br>
* Statement, PreparedStatement, CallableStatement, DatabaseMetaData
*/
public class ConnectionWrapper40 extends ConnectionHolder40 implements ConnectionWrapper {
@@ -30,13 +41,12 @@
/**
* Instantiates connection wrapper to wrap JDBC objects.
*
- * @param con Connection that is wrapped
- * @param mc Managed Connection
+ * @param con Connection that is wrapped
+ * @param mc Managed Connection
* @param cxRequestInfo Connection Request Info
*/
- public ConnectionWrapper40(Connection con, ManagedConnectionImpl mc,
- jakarta.resource.spi.ConnectionRequestInfo cxRequestInfo,
- boolean jdbc30Connection) {
+ public ConnectionWrapper40(Connection con, ManagedConnectionImpl mc, ConnectionRequestInfo cxRequestInfo,
+ boolean jdbc30Connection) {
super(con, mc, cxRequestInfo, jdbc30Connection);
}
@@ -46,37 +56,36 @@
* @return <code>Statement</code> object.
* @throws java.sql.SQLException In case of a database error.
*/
+ @Override
public Statement createStatement() throws SQLException {
-
return new StatementWrapper40(this, super.createStatement());
}
/**
* Creates a statement from the underlying Connection.
*
- * @param resultSetType Type of the ResultSet
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code>Statement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
- return new StatementWrapper40(this, super.createStatement(resultSetType,
- resultSetConcurrency));
+ return new StatementWrapper40(this, super.createStatement(resultSetType, resultSetConcurrency));
}
/**
* Creates a statement from the underlying Connection.
*
- * @param resultSetType Type of the ResultSet
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code>Statement</code> object.
* @throws SQLException In case of a database error.
*/
- public Statement createStatement(int resultSetType, int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
- return new StatementWrapper40(this, super.createStatement(resultSetType,
- resultSetConcurrency, resultSetHoldability));
+ @Override
+ public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+ return new StatementWrapper40(this, super.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability));
}
/**
@@ -86,195 +95,187 @@
* @return <code>DatabaseMetaData</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public DatabaseMetaData getMetaData() throws SQLException {
return new DatabaseMetaDataWrapper40(this, super.getMetaData());
}
-
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
* @param sql SQL Statement
* @return <code> CallableStatement</code> object.
* @throws java.sql.SQLException In case of a database error.
*/
+ @Override
public CallableStatement prepareCall(String sql) throws SQLException {
- return mc.prepareCachedCallableStatement(this, sql, ResultSet.TYPE_FORWARD_ONLY,
- ResultSet.CONCUR_READ_ONLY);
+ return managedConnectionImpl.prepareCachedCallableStatement(this, sql, TYPE_FORWARD_ONLY, CONCUR_READ_ONLY);
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code> CallableStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public CallableStatement prepareCall(String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
- return mc.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency);
+ @Override
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ return managedConnectionImpl.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency);
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code> CallableStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public CallableStatement prepareCall(String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
- return mc.prepareCachedCallableStatement(this, sql, resultSetType,
- resultSetConcurrency, resultSetHoldability);
+ @Override
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+ return managedConnectionImpl.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
* @param sql SQL Statement
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public PreparedStatement prepareStatement(String sql) throws SQLException {
- return mc.prepareCachedStatement(this, sql, ResultSet.TYPE_FORWARD_ONLY,
- ResultSet.CONCUR_READ_ONLY);
+ return managedConnectionImpl.prepareCachedStatement(this, sql, TYPE_FORWARD_ONLY, CONCUR_READ_ONLY);
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param autoGeneratedKeys a flag indicating AutoGeneratedKeys need to be returned.
+ * @param sql SQL Statement
+ * @param autoGeneratedKeys a flag indicating AutoGeneratedKeys need to be
+ * returned.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
- return mc.prepareCachedStatement(this, sql, autoGeneratedKeys);
+ @Override
+ public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+ return managedConnectionImpl.prepareCachedStatement(this, sql, autoGeneratedKeys);
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param columnIndexes an array of column indexes indicating the columns that should be
- * returned from the inserted row or rows.
+ * @param sql SQL Statement
+ * @param columnIndexes an array of column indexes indicating the columns that
+ * should be returned from the inserted row or rows.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
- return mc.prepareCachedStatement(this, sql, columnIndexes);
+ @Override
+ public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
+ return managedConnectionImpl.prepareCachedStatement(this, sql, columnIndexes);
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
- return mc.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency);
+ @Override
+ public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ return managedConnectionImpl.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency);
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
- return mc.prepareCachedStatement(this, sql, resultSetType,
- resultSetConcurrency, resultSetHoldability);
+ @Override
+ public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+ return managedConnectionImpl.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
+ * @param sql SQL Statement
* @param columnNames Name of bound columns.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
+ @Override
+ public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
checkValidity();
jdbcPreInvoke();
- return mc.prepareCachedStatement(this, sql, columnNames);
+ return managedConnectionImpl.prepareCachedStatement(this, sql, columnNames);
}
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this, super.prepareStatement(sql,
- resultSetType, resultSetConcurrency), enableCaching);
- }
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int resultSetType, int resultSetConcurrency, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(
+ this,
+ super.prepareStatement(sql, resultSetType, resultSetConcurrency),
+ enableCaching);
+ }
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- String[] columnNames, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareStatement(sql, columnNames), enableCaching);
- }
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, String[] columnNames, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, columnNames), enableCaching);
+ }
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency, int resultSetHoldability,
- boolean enableCaching) throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
- enableCaching);
- }
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(
+ this,
+ super.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
+ enableCaching);
+ }
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int[] columnIndexes, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareStatement(sql, columnIndexes), enableCaching);
- }
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int[] columnIndexes, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, columnIndexes), enableCaching);
+ }
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int autoGeneratedKeys, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareStatement(sql, autoGeneratedKeys), enableCaching);
- }
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int autoGeneratedKeys, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, autoGeneratedKeys), enableCaching);
+ }
- public CallableStatementWrapper40 callableCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency, boolean enableCaching)
- throws SQLException {
- return new CallableStatementWrapper40(this, super.prepareCall(sql,
- resultSetType, resultSetConcurrency), enableCaching);
- }
+ @Override
+ public CallableStatementWrapper40 callableCachedStatement(String sql, int resultSetType, int resultSetConcurrency, boolean enableCaching) throws SQLException {
+ return new CallableStatementWrapper40(this, super.prepareCall(sql, resultSetType, resultSetConcurrency), enableCaching);
+ }
- public CallableStatementWrapper40 callableCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency,
- int resultSetHoldability, boolean enableCaching)
- throws SQLException {
- return new CallableStatementWrapper40(this, super.prepareCall(sql,
- resultSetType, resultSetConcurrency, resultSetHoldability),
- enableCaching);
- }
+ @Override
+ public CallableStatementWrapper40 callableCachedStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, boolean enableCaching) throws SQLException {
+ return new CallableStatementWrapper40(
+ this,
+ super.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
+ enableCaching);
+ }
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DataSource40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DataSource40.java
index 00c0878..3f5e3f9 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DataSource40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DataSource40.java
@@ -16,38 +16,41 @@
package com.sun.gjc.spi.jdbc40;
+import static com.sun.gjc.common.DataSourceObjectBuilder.isJDBC41;
+import static java.util.logging.Level.SEVERE;
+import static java.util.logging.Level.WARNING;
+
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.Wrapper;
+import java.util.logging.Logger;
+
import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
import com.sun.gjc.spi.base.AbstractDataSource;
import jakarta.resource.ResourceException;
import jakarta.resource.spi.ConnectionManager;
-import java.util.logging.Level;
-import java.sql.*;
-import java.util.logging.Logger;
/**
- * Holds the <code>java.sql.Connection</code> object, which is to be
- * passed to the application program.
+ * Holds the <code>java.sql.Connection</code> object, which is to be passed to
+ * the application program.
*
* @author Binod P.G
* @version 1.0, 02/07/31
*/
public class DataSource40 extends AbstractDataSource {
-
- protected final static StringManager localStrings =
- StringManager.getManager(ManagedConnectionFactoryImpl.class);
+ private static final long serialVersionUID = 1L;
+ protected final static StringManager localStrings = StringManager.getManager(ManagedConnectionFactoryImpl.class);
/**
* Constructs <code>DataSource</code> object. This is created by the
* <code>ManagedConnectionFactory</code> object.
*
- * @param mcf <code>ManagedConnectionFactory</code> object
- * creating this object.
- * @param cm <code>ConnectionManager</code> object either associated
- * with Application server or Resource Adapter.
+ * @param mcf <code>ManagedConnectionFactory</code> object creating this object.
+ * @param cm <code>ConnectionManager</code> object either associated with
+ * Application server or Resource Adapter.
*/
public DataSource40(ManagedConnectionFactoryImpl mcf, ConnectionManager cm) {
super(mcf, cm);
@@ -57,23 +60,26 @@
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
T result;
try {
- Object cds = mcf.getDataSource();
+ Object cds = managedConnectionFactoryImpl.getDataSource();
if (iface.isInstance(cds)) {
result = iface.cast(cds);
@@ -84,54 +90,62 @@
throw new SQLException(msg);
}
} catch (ResourceException e) {
- _logger.log(Level.WARNING, "jdbc.exc_unwrap", e);
+ _logger.log(WARNING, "jdbc.exc_unwrap", e);
throw new SQLException(e);
}
+
return result;
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
boolean result = false;
try {
- Object cds = mcf.getDataSource();
+ Object cds = managedConnectionFactoryImpl.getDataSource();
if (iface.isInstance(cds)) {
result = true;
} else if (cds instanceof java.sql.Wrapper) {
- result = ((java.sql.Wrapper) cds).isWrapperFor(iface);
+ result = ((Wrapper) cds).isWrapperFor(iface);
}
} catch (ResourceException e) {
- _logger.log(Level.WARNING, "jdbc.exc_is_wrapper", e);
+ _logger.log(WARNING, "jdbc.exc_is_wrapper", e);
throw new SQLException(e);
}
return result;
}
+ @Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
- if(DataSourceObjectBuilder.isJDBC41()) {
- try {
- return (Logger) executor.invokeMethod(mcf.getDataSource().getClass(),
- "getParentLogger", null);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_get_parent_logger", ex);
- throw new SQLFeatureNotSupportedException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ try {
+ return (Logger) executor.invokeMethod(managedConnectionFactoryImpl.getDataSource().getClass(), "getParentLogger", null);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_get_parent_logger", ex);
+ throw new SQLFeatureNotSupportedException(ex);
+ }
+
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DatabaseMetaDataWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DatabaseMetaDataWrapper40.java
index 36e6c0d..5ac0227 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DatabaseMetaDataWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/DatabaseMetaDataWrapper40.java
@@ -16,11 +16,16 @@
package com.sun.gjc.spi.jdbc40;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.RowIdLifetime;
+import java.sql.SQLException;
+import java.util.logging.Level;
+
import com.sun.gjc.common.DataSourceObjectBuilder;
import com.sun.gjc.spi.base.DatabaseMetaDataWrapper;
-import java.sql.*;
-import java.util.logging.Level;
import jakarta.resource.ResourceException;
/**
@@ -31,7 +36,7 @@
/**
* Creates a new instance of DatabaseMetaDataWrapper40 for JDBC 4.0
*
- * @param con Connection that is wrapped
+ * @param con Connection that is wrapped
* @param metaData DatabaseMetaData that is wrapped
*/
public DatabaseMetaDataWrapper40(Connection con, DatabaseMetaData metaData) {
@@ -39,256 +44,270 @@
}
/**
- * Indicates whether or not this data source supports the SQL <code>ROWID</code> type,
- * and if so the lifetime for which a <code>RowId</code> object remains valid.
+ * Indicates whether or not this data source supports the SQL <code>ROWID</code>
+ * type, and if so the lifetime for which a <code>RowId</code> object remains
+ * valid.
* <p/>
* The returned int values have the following relationship:
+ *
* <pre>
- * ROWID_UNSUPPORTED < ROWID_VALID_OTHER < ROWID_VALID_TRANSACTION
- * < ROWID_VALID_SESSION < ROWID_VALID_FOREVER
+ * ROWID_UNSUPPORTED < ROWID_VALID_OTHER < ROWID_VALID_TRANSACTION < ROWID_VALID_SESSION < ROWID_VALID_FOREVER
* </pre>
+ *
* so conditional logic such as
+ *
* <pre>
* if (metadata.getRowIdLifetime() > DatabaseMetaData.ROWID_VALID_TRANSACTION)
* </pre>
- * can be used. Valid Forever means valid across all Sessions, and valid for
- * a Session means valid across all its contained Transactions.
+ *
+ * can be used. Valid Forever means valid across all Sessions, and valid for a
+ * Session means valid across all its contained Transactions.
*
* @return the status indicating the lifetime of a <code>RowId</code>
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public RowIdLifetime getRowIdLifetime() throws SQLException {
return databaseMetaData.getRowIdLifetime();
}
/**
- * Retrieves the schema names available in this database. The results
- * are ordered by <code>TABLE_CATALOG</code> and
- * <code>TABLE_SCHEM</code>.
+ * Retrieves the schema names available in this database. The results are
+ * ordered by <code>TABLE_CATALOG</code> and <code>TABLE_SCHEM</code>.
* <p/>
- * <P>The schema columns are:
+ * <P>
+ * The schema columns are:
* <OL>
* <LI><B>TABLE_SCHEM</B> String => schema name
* <LI><B>TABLE_CATALOG</B> String => catalog name (may be <code>null</code>)
* </OL>
*
- * @param catalog a catalog name; must match the catalog name as it is stored
- * in the database;"" retrieves those without a catalog; null means catalog
- * name should not be used to narrow down the search.
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database;"" retrieves those without a catalog; null means catalog name
+ * should not be used to narrow down the search.
* @param schemaPattern a schema name; must match the schema name as it is
- * stored in the database; null means
- * schema name should not be used to narrow down the search.
- * @return a <code>ResultSet</code> object in which each row is a
- * schema description
+ * stored in the database; null means schema name should not be used to narrow
+ * down the search.
+ * @return a <code>ResultSet</code> object in which each row is a schema
+ * description
* @throws SQLException if a database access error occurs
* @see #getSearchStringEscape
* @since 1.6
*/
+ @Override
public ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException {
return databaseMetaData.getSchemas(catalog, schemaPattern);
}
/**
- * Retrieves whether this database supports invoking user-defined or vendor functions
- * using the stored procedure escape syntax.
+ * Retrieves whether this database supports invoking user-defined or vendor
+ * functions using the stored procedure escape syntax.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
return databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
}
/**
- * Retrieves whether a <code>SQLException</code> while autoCommit is <code>true</code> inidcates
- * that all open ResultSets are closed, even ones that are holdable. When a <code>SQLException</code> occurs while
- * autocommit is <code>true</code>, it is vendor specific whether the JDBC driver responds with a commit operation, a
- * rollback operation, or by doing neither a commit nor a rollback. A potential result of this difference
- * is in whether or not holdable ResultSets are closed.
+ * Retrieves whether a <code>SQLException</code> while autoCommit is
+ * <code>true</code> inidcates that all open ResultSets are closed, even ones
+ * that are holdable. When a <code>SQLException</code> occurs while autocommit
+ * is <code>true</code>, it is vendor specific whether the JDBC driver responds
+ * with a commit operation, a rollback operation, or by doing neither a commit
+ * nor a rollback. A potential result of this difference is in whether or not
+ * holdable ResultSets are closed.
*
* @return <code>true</code> if so; <code>false</code> otherwise
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
return databaseMetaData.autoCommitFailureClosesAllResultSets();
}
/**
- * Retrieves a list of the client info properties
- * that the driver supports. The result set contains the following columns
+ * Retrieves a list of the client info properties that the driver supports. The
+ * result set contains the following columns
* <p/>
* <ol>
* <li><b>NAME</b> String=> The name of the client info property<br>
* <li><b>MAX_LEN</b> int=> The maximum length of the value for the property<br>
* <li><b>DEFAULT_VALUE</b> String=> The default value of the property<br>
- * <li><b>DESCRIPTION</b> String=> A description of the property. This will typically
- * contain information as to where this property is
- * stored in the database.
+ * <li><b>DESCRIPTION</b> String=> A description of the property. This will
+ * typically contain information as to where this property is stored in the
+ * database.
* </ol>
* <p/>
* The <code>ResultSet</code> is sorted by the NAME column
* <p/>
*
* @throws SQLException if a database access error occurs
- * <p/>
+ * <p/>
* @return A <code>ResultSet</code> object; each row is a supported client info
* property
* <p/>
* @since 1.6
*/
+ @Override
public ResultSet getClientInfoProperties() throws SQLException {
return databaseMetaData.getClientInfoProperties();
}
/**
- * Retrieves a description of the system and user functions available
- * in the given catalog.
+ * Retrieves a description of the system and user functions available in the
+ * given catalog.
* <p/>
- * Only system and user function descriptions matching the schema and
- * function name criteria are returned. They are ordered by
- * <code>FUNCTION_CAT</code>, <code>FUNCTION_SCHEM</code>,
- * <code>FUNCTION_NAME</code> and
+ * Only system and user function descriptions matching the schema and function
+ * name criteria are returned. They are ordered by <code>FUNCTION_CAT</code>,
+ * <code>FUNCTION_SCHEM</code>, <code>FUNCTION_NAME</code> and
* <code>SPECIFIC_ NAME</code>.
* <p/>
- * <P>Each function description has the the following columns:
+ * <P>
+ * Each function description has the the following columns:
* <OL>
* <LI><B>FUNCTION_CAT</B> String => function catalog (may be <code>null</code>)
- * <LI><B>FUNCTION_SCHEM</B> String => function schema (may be <code>null</code>)
- * <LI><B>FUNCTION_NAME</B> String => function name. This is the name
- * used to invoke the function
+ * <LI><B>FUNCTION_SCHEM</B> String => function schema (may be
+ * <code>null</code>)
+ * <LI><B>FUNCTION_NAME</B> String => function name. This is the name used to
+ * invoke the function
* <LI><B>REMARKS</B> String => explanatory comment on the function
* <LI><B>FUNCTION_TYPE</B> short => kind of function:
* <UL>
- * <LI>functionResultUnknown - Cannot determine if a return value
- * or table will be returned
- * <LI> functionNoTable- Does not return a table
- * <LI> functionReturnsTable - Returns a table
+ * <LI>functionResultUnknown - Cannot determine if a return value or table will
+ * be returned
+ * <LI>functionNoTable- Does not return a table
+ * <LI>functionReturnsTable - Returns a table
* </UL>
- * <LI><B>SPECIFIC_NAME</B> String => the name which uniquely identifies
- * this function within its schema. This is a user specified, or DBMS
- * generated, name that may be different then the <code>FUNCTION_NAME</code>
- * for example with overload functions
+ * <LI><B>SPECIFIC_NAME</B> String => the name which uniquely identifies this
+ * function within its schema. This is a user specified, or DBMS generated, name
+ * that may be different then the <code>FUNCTION_NAME</code> for example with
+ * overload functions
* </OL>
* <p/>
* A user may not have permission to execute any of the functions that are
* returned by <code>getFunctions</code>
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param functionNamePattern a function name pattern; must match the
- * function name as it is stored in the database
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param functionNamePattern a function name pattern; must match the function
+ * name as it is stored in the database
* @return <code>ResultSet</code> - each row is a function description
* @throws SQLException if a database access error occurs
* @see #getSearchStringEscape
* @since 1.6
*/
+ @Override
public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException {
return databaseMetaData.getFunctions(catalog, schemaPattern, functionNamePattern);
}
/**
- * Retrieves a description of the given catalog's system or user
- * function parameters and return type.
+ * Retrieves a description of the given catalog's system or user function
+ * parameters and return type.
* <p/>
- * <P>Only descriptions matching the schema, function and
- * parameter name criteria are returned. They are ordered by
- * <code>FUNCTION_CAT</code>, <code>FUNCTION_SCHEM</code>,
- * <code>FUNCTION_NAME</code> and
- * <code>SPECIFIC_ NAME</code>. Within this, the return value,
- * if any, is first. Next are the parameter descriptions in call
- * order. The column descriptions follow in column number order.
+ * <P>
+ * Only descriptions matching the schema, function and parameter name criteria
+ * are returned. They are ordered by <code>FUNCTION_CAT</code>,
+ * <code>FUNCTION_SCHEM</code>, <code>FUNCTION_NAME</code> and
+ * <code>SPECIFIC_ NAME</code>. Within this, the return value, if any, is first.
+ * Next are the parameter descriptions in call order. The column descriptions
+ * follow in column number order.
* <p/>
- * <P>Each row in the <code>ResultSet</code>
- * is a parameter description, column description or
- * return type description with the following fields:
+ * <P>
+ * Each row in the <code>ResultSet</code> is a parameter description, column
+ * description or return type description with the following fields:
* <OL>
* <LI><B>FUNCTION_CAT</B> String => function catalog (may be <code>null</code>)
- * <LI><B>FUNCTION_SCHEM</B> String => function schema (may be <code>null</code>)
- * <LI><B>FUNCTION_NAME</B> String => function name. This is the name
- * used to invoke the function
+ * <LI><B>FUNCTION_SCHEM</B> String => function schema (may be
+ * <code>null</code>)
+ * <LI><B>FUNCTION_NAME</B> String => function name. This is the name used to
+ * invoke the function
* <LI><B>COLUMN_NAME</B> String => column/parameter name
* <LI><B>COLUMN_TYPE</B> Short => kind of column/parameter:
* <UL>
- * <LI> functionColumnUnknown - nobody knows
- * <LI> functionColumnIn - IN parameter
- * <LI> functionColumnInOut - INOUT parameter
- * <LI> functionColumnOut - OUT parameter
- * <LI> functionColumnReturn - function return value
- * <LI> functionColumnResult - Indicates that the parameter or column
- * is a column in the <code>ResultSet</code>
+ * <LI>functionColumnUnknown - nobody knows
+ * <LI>functionColumnIn - IN parameter
+ * <LI>functionColumnInOut - INOUT parameter
+ * <LI>functionColumnOut - OUT parameter
+ * <LI>functionColumnReturn - function return value
+ * <LI>functionColumnResult - Indicates that the parameter or column is a column
+ * in the <code>ResultSet</code>
* </UL>
* <LI><B>DATA_TYPE</B> int => SQL type from java.sql.Types
- * <LI><B>TYPE_NAME</B> String => SQL type name, for a UDT type the
- * type name is fully qualified
+ * <LI><B>TYPE_NAME</B> String => SQL type name, for a UDT type the type name is
+ * fully qualified
* <LI><B>PRECISION</B> int => precision
* <LI><B>LENGTH</B> int => length in bytes of data
- * <LI><B>SCALE</B> short => scale - null is returned for data types where
- * SCALE is not applicable.
+ * <LI><B>SCALE</B> short => scale - null is returned for data types where SCALE
+ * is not applicable.
* <LI><B>RADIX</B> short => radix
* <LI><B>NULLABLE</B> short => can it contain NULL.
* <UL>
- * <LI> functionNoNulls - does not allow NULL values
- * <LI> functionNullable - allows NULL values
- * <LI> functionNullableUnknown - nullability unknown
+ * <LI>functionNoNulls - does not allow NULL values
+ * <LI>functionNullable - allows NULL values
+ * <LI>functionNullableUnknown - nullability unknown
* </UL>
* <LI><B>REMARKS</B> String => comment describing column/parameter
- * <LI><B>CHAR_OCTET_LENGTH</B> int => the maximum length of binary
- * and character based parameters or columns. For any other datatype the returned value
- * is a NULL
- * <LI><B>ORDINAL_POSITION</B> int => the ordinal position, starting
- * from 1, for the input and output parameters. A value of 0
- * is returned if this row describes the function's return value.
- * For result set columns, it is the
+ * <LI><B>CHAR_OCTET_LENGTH</B> int => the maximum length of binary and
+ * character based parameters or columns. For any other datatype the returned
+ * value is a NULL
+ * <LI><B>ORDINAL_POSITION</B> int => the ordinal position, starting from 1, for
+ * the input and output parameters. A value of 0 is returned if this row
+ * describes the function's return value. For result set columns, it is the
* ordinal position of the column in the result set starting from 1.
- * <LI><B>IS_NULLABLE</B> String => ISO rules are used to determine
- * the nullability for a parameter or column.
+ * <LI><B>IS_NULLABLE</B> String => ISO rules are used to determine the
+ * nullability for a parameter or column.
* <UL>
- * <LI> YES --- if the parameter or column can include NULLs
- * <LI> NO --- if the parameter or column cannot include NULLs
- * <LI> empty string --- if the nullability for the
- * parameter or column is unknown
+ * <LI>YES --- if the parameter or column can include NULLs
+ * <LI>NO --- if the parameter or column cannot include NULLs
+ * <LI>empty string --- if the nullability for the parameter or column is
+ * unknown
* </UL>
- * <LI><B>SPECIFIC_NAME</B> String => the name which uniquely identifies
- * this function within its schema. This is a user specified, or DBMS
- * generated, name that may be different then the <code>FUNCTION_NAME</code>
- * for example with overload functions
+ * <LI><B>SPECIFIC_NAME</B> String => the name which uniquely identifies this
+ * function within its schema. This is a user specified, or DBMS generated, name
+ * that may be different then the <code>FUNCTION_NAME</code> for example with
+ * overload functions
* </OL>
* <p/>
- * <p>The PRECISION column represents the specified column size for the given
- * parameter or column.
- * For numeric data, this is the maximum precision. For character data, this is the length in characters.
- * For datetime datatypes, this is the length in characters of the String representation (assuming the
- * maximum allowed precision of the fractional seconds component). For binary data, this is the length in bytes. For the ROWID datatype,
- * this is the length in bytes. Null is returned for data types where the
- * column size is not applicable.
+ * <p>
+ * The PRECISION column represents the specified column size for the given
+ * parameter or column. For numeric data, this is the maximum precision. For
+ * character data, this is the length in characters. For datetime datatypes,
+ * this is the length in characters of the String representation (assuming the
+ * maximum allowed precision of the fractional seconds component). For binary
+ * data, this is the length in bytes. For the ROWID datatype, this is the length
+ * in bytes. Null is returned for data types where the column size is not
+ * applicable.
*
- * @param catalog a catalog name; must match the catalog name as it
- * is stored in the database; "" retrieves those without a catalog;
- * <code>null</code> means that the catalog name should not be used to narrow
- * the search
- * @param schemaPattern a schema name pattern; must match the schema name
- * as it is stored in the database; "" retrieves those without a schema;
- * <code>null</code> means that the schema name should not be used to narrow
- * the search
- * @param functionNamePattern a procedure name pattern; must match the
- * function name as it is stored in the database
- * @param columnNamePattern a parameter name pattern; must match the
- * parameter or column name as it is stored in the database
- * @return <code>ResultSet</code> - each row describes a
- * user function parameter, column or return type
+ * @param catalog a catalog name; must match the catalog name as it is stored in
+ * the database; "" retrieves those without a catalog; <code>null</code> means
+ * that the catalog name should not be used to narrow the search
+ * @param schemaPattern a schema name pattern; must match the schema name as it
+ * is stored in the database; "" retrieves those without a schema;
+ * <code>null</code> means that the schema name should not be used to narrow the
+ * search
+ * @param functionNamePattern a procedure name pattern; must match the function
+ * name as it is stored in the database
+ * @param columnNamePattern a parameter name pattern; must match the parameter
+ * or column name as it is stored in the database
+ * @return <code>ResultSet</code> - each row describes a user function
+ * parameter, column or return type
* @throws SQLException if a database access error occurs
* @see #getSearchStringEscape
* @since 1.6
*/
+ @Override
public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException {
return databaseMetaData.getFunctionColumns(catalog, schemaPattern, functionNamePattern, columnNamePattern);
}
@@ -297,19 +316,22 @@
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
T result;
if (iface.isInstance(this)) {
@@ -321,20 +343,25 @@
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
boolean result;
if (iface.isInstance(this)) {
@@ -345,15 +372,14 @@
return result;
}
- public ResultSet getPseudoColumns(String catalog, String schemaPattern,
- String tableNamePattern, String columnNamePattern) throws SQLException {
+ @Override
+ public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)
+ throws SQLException {
if (DataSourceObjectBuilder.isJDBC41()) {
- Class<?>[] valueTypes =
- new Class<?>[]{String.class, String.class, String.class, String.class};
+ Class<?>[] valueTypes = new Class<?>[] { String.class, String.class, String.class, String.class };
try {
- return (ResultSet) getMethodExecutor().invokeMethod(databaseMetaData,
- "getPseudoColumns", valueTypes, catalog, schemaPattern,
- tableNamePattern, columnNamePattern);
+ return (ResultSet) getMethodExecutor().invokeMethod(databaseMetaData, "getPseudoColumns", valueTypes, catalog,
+ schemaPattern, tableNamePattern, columnNamePattern);
} catch (ResourceException ex) {
_logger.log(Level.SEVERE, "jdbc.ex_dmd_wrapper", ex);
throw new SQLException(ex);
@@ -362,11 +388,11 @@
throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
+ @Override
public boolean generatedKeyAlwaysReturned() throws SQLException {
if (DataSourceObjectBuilder.isJDBC41()) {
try {
- return (Boolean) getMethodExecutor().invokeMethod(databaseMetaData,
- "generatedKeyAlwaysReturned", null);
+ return (Boolean) getMethodExecutor().invokeMethod(databaseMetaData, "generatedKeyAlwaysReturned", null);
} catch (ResourceException ex) {
_logger.log(Level.SEVERE, "jdbc.ex_dmd_wrapper", ex);
throw new SQLException(ex);
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/Jdbc40ObjectsFactory.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/Jdbc40ObjectsFactory.java
index ae9f258..860d230 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/Jdbc40ObjectsFactory.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/Jdbc40ObjectsFactory.java
@@ -16,52 +16,58 @@
package com.sun.gjc.spi.jdbc40;
+import static java.lang.reflect.Modifier.isAbstract;
+
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.util.logging.Level;
+
+import javax.sql.DataSource;
+
import com.sun.gjc.spi.JdbcObjectsFactory;
import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
import com.sun.gjc.spi.ManagedConnectionImpl;
import com.sun.gjc.spi.base.ConnectionHolder;
-
import com.sun.gjc.util.SQLTraceDelegator;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.sql.Connection;
-import java.util.logging.Level;
+import jakarta.resource.spi.ConnectionManager;
/**
* Factory to create jdbc40 connection & datasource
*/
public class Jdbc40ObjectsFactory extends JdbcObjectsFactory {
- //indicates whether JDBC 3.0 Connection (and hence JDBC 3.0 DataSource) is used
+
+ private static final long serialVersionUID = 1L;
+
+ // indicates whether JDBC 3.0 Connection (and hence JDBC 3.0 DataSource) is used
private boolean jdbc30Connection;
- //indicates whether detection of JDBC 3.0 Datasource in JDK 1.6 is done or not
+
+ // indicates whether detection of JDBC 3.0 Datasource in JDK 1.6 is done or not
private boolean initJDBC30Connection;
/**
* To get an instance of ConnectionHolder40.<br>
* Will return a ConnectionHolder40 with or without wrapper<br>
*
- * @param conObject Connection
- * @param mcObject ManagedConnection
- * @param criObject Connection Request Info
+ * @param conObject Connection
+ * @param mcObject ManagedConnection
+ * @param criObject Connection Request Info
* @param statementWrapping Whether to wrap statement objects or not.
* @return ConnectionHolder
*/
- public ConnectionHolder getConnection(Connection conObject,
- ManagedConnectionImpl mcObject,
- jakarta.resource.spi.ConnectionRequestInfo criObject,
- boolean statementWrapping,
- SQLTraceDelegator sqlTraceDelegator) {
+ @Override
+ public ConnectionHolder getConnection(Connection conObject, ManagedConnectionImpl mcObject,
+ jakarta.resource.spi.ConnectionRequestInfo criObject, boolean statementWrapping, SQLTraceDelegator sqlTraceDelegator) {
ConnectionHolder connection = null;
if (!initJDBC30Connection) {
detectJDBC30Connection(conObject, mcObject);
}
+
if (statementWrapping) {
if (sqlTraceDelegator != null) {
- Class connIntf[] = new Class[]{java.sql.Connection.class};
+ Class<?>[] connIntf = new Class[] { Connection.class };
Connection proxiedConn = getProxiedConnection(conObject, connIntf, sqlTraceDelegator);
- connection = new ProfiledConnectionWrapper40(proxiedConn, mcObject,
- criObject, jdbc30Connection, sqlTraceDelegator);
+ connection = new ProfiledConnectionWrapper40(proxiedConn, mcObject, criObject, jdbc30Connection, sqlTraceDelegator);
} else {
connection = new ConnectionWrapper40(conObject, mcObject, criObject, jdbc30Connection);
}
@@ -75,11 +81,11 @@
* Returns a DataSource instance for JDBC 4.0
*
* @param mcfObject Managed Connection Factory
- * @param cmObject Connection Manager
+ * @param cmObject Connection Manager
* @return DataSource
*/
- public javax.sql.DataSource getDataSourceInstance(ManagedConnectionFactoryImpl mcfObject,
- jakarta.resource.spi.ConnectionManager cmObject) {
+ @Override
+ public DataSource getDataSourceInstance(ManagedConnectionFactoryImpl mcfObject, ConnectionManager cmObject) {
return new DataSource40(mcfObject, cmObject);
}
@@ -96,21 +102,17 @@
}
public void detectJDBC30Connection(Connection con, ManagedConnectionImpl mcObject) {
-
String dataSourceProperty = mcObject.getManagedConnectionFactory().getJdbc30DataSource();
if (dataSourceProperty != null) {
setJdbc30Connection(Boolean.valueOf(dataSourceProperty));
initJDBC30Connection = true;
} else {
try {
- Class paramClasses[] = new Class[]{Class.class};
+ Class<?>[] paramClasses = new Class[] { Class.class };
Method isWrapperMethod = con.getClass().getMethod("isWrapperFor", paramClasses);
- int modifiers = isWrapperMethod.getModifiers();
- setJdbc30Connection(Modifier.isAbstract(modifiers));
- } catch (NoSuchMethodException e) {
- setJdbc30Connection(true);
- } catch (AbstractMethodError e) {
+ setJdbc30Connection(isAbstract(isWrapperMethod.getModifiers()));
+ } catch (NoSuchMethodException | AbstractMethodError e) {
setJdbc30Connection(true);
} catch (Throwable t) {
setJdbc30Connection(true);
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/PreparedStatementWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/PreparedStatementWrapper40.java
index 287b366..84f1fb9 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/PreparedStatementWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/PreparedStatementWrapper40.java
@@ -16,12 +16,18 @@
package com.sun.gjc.spi.jdbc40;
-import com.sun.gjc.spi.base.PreparedStatementWrapper;
-
import java.io.InputStream;
import java.io.Reader;
-import java.sql.*;
+import java.sql.Connection;
+import java.sql.NClob;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.SQLXML;
+import com.sun.gjc.spi.base.PreparedStatementWrapper;
/**
* Wrapper for JDBC 4.0 PreparedStatement
@@ -31,523 +37,550 @@
/**
* Creates a new instance of PreparedStatement Wrapper for JDBC 3.0<br>
*
- * @param con ConnectionWrapper<br>
+ * @param con ConnectionWrapper<br>
* @param statement PreparedStatement that is wrapped<br>
*/
- public PreparedStatementWrapper40(Connection con,
- PreparedStatement statement, boolean statementCaching)
- throws SQLException {
+ public PreparedStatementWrapper40(Connection con, PreparedStatement statement, boolean statementCaching) throws SQLException {
super(con, statement, statementCaching);
}
/**
- * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
- * driver converts this to a SQL <code>ROWID</code> value when it sends it
- * to the database
+ * Sets the designated parameter to the given <code>java.sql.RowId</code>
+ * object. The driver converts this to a SQL <code>ROWID</code> value when it
+ * sends it to the database
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the parameter value
+ * @param x the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setRowId(int parameterIndex, RowId x) throws SQLException {
preparedStatement.setRowId(parameterIndex, x);
}
/**
- * Sets the designated paramter to the given <code>String</code> object.
- * The driver converts this to a SQL <code>NCHAR</code> or
- * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
- * (depending on the argument's
- * size relative to the driver's limits on <code>NVARCHAR</code> values)
- * when it sends it to the database.
+ * Sets the designated paramter to the given <code>String</code> object. The
+ * driver converts this to a SQL <code>NCHAR</code> or <code>NVARCHAR</code> or
+ * <code>LONGNVARCHAR</code> value (depending on the argument's size relative to
+ * the driver's limits on <code>NVARCHAR</code> values) when it sends it to the
+ * database.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNString(int parameterIndex, String value) throws SQLException {
preparedStatement.setNString(parameterIndex, value);
}
/**
* Sets the designated parameter to a <code>Reader</code> object. The
- * <code>Reader</code> reads the data till end-of-file is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
+ * <code>Reader</code> reads the data till end-of-file is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
- * @param length the number of characters in the parameter data.
+ * @param value the parameter value
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
preparedStatement.setNCharacterStream(parameterIndex, value, length);
}
/**
- * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to a
- * SQL <code>NCLOB</code> value when it sends it to the database.
+ * Sets the designated parameter to a <code>java.sql.NClob</code> object. The
+ * driver converts this to a SQL <code>NCLOB</code> value when it sends it to
+ * the database.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(int parameterIndex, NClob value) throws SQLException {
preparedStatement.setNClob(parameterIndex, value);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>PreparedStatement</code> is executed.
- * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. The reader
+ * must contain the number of characters specified by length otherwise a
+ * <code>SQLException</code> will be generated when the
+ * <code>PreparedStatement</code> is executed. This method differs from the
+ * <code>setCharacterStream (int, Reader, int)</code> method because it informs
+ * the driver that the parameter value should be sent to the server as a
+ * <code>CLOB</code>. When the <code>setCharacterStream</code> method is used,
+ * the driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGVARCHAR</code> or a
+ * <code>CLOB</code>
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs; this method is called on
- * a closed <code>PreparedStatement</code> or if the length specified is less than zero.
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code> or if the length
+ * specified is less than zero.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
preparedStatement.setClob(parameterIndex, reader, length);
}
/**
- * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>PreparedStatement</code> is executed.
- * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
- * method because it informs the driver that the parameter value should be
- * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
- * the driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
+ * Sets the designated parameter to a <code>InputStream</code> object. The
+ * inputstream must contain the number of characters specified by length
+ * otherwise a <code>SQLException</code> will be generated when the
+ * <code>PreparedStatement</code> is executed. This method differs from the
+ * <code>setBinaryStream (int, InputStream, int)</code> method because it
+ * informs the driver that the parameter value should be sent to the server as a
+ * <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, the
+ * driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGVARBINARY</code> or a
+ * <code>BLOB</code>
*
- * @param parameterIndex index of the first parameter is 1,
- * the second is 2, ...
- * @param inputStream An object that contains the data to set the parameter
- * value to.
- * @param length the number of bytes in the parameter data.
+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
+ * @param inputStream An object that contains the data to set the parameter
+ * value to.
+ * @param length the number of bytes in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code>;
- * if the length specified
- * is less than zero or if the number of bytes in the inputstream does not match
- * the specfied length.
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code>; if the length specified
+ * is less than zero or if the number of bytes in the inputstream does not match
+ * the specfied length.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
preparedStatement.setBlob(parameterIndex, inputStream, length);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
- * of characters specified by length otherwise a <code>SQLException</code> will be
- * generated when the <code>PreparedStatement</code> is executed.
- * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. The reader
+ * must contain the number of characters specified by length otherwise a
+ * <code>SQLException</code> will be generated when the
+ * <code>PreparedStatement</code> is executed. This method differs from the
+ * <code>setCharacterStream (int, Reader, int)</code> method because it informs
+ * the driver that the parameter value should be sent to the server as a
+ * <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used,
+ * the driver may have to do extra work to determine whether the parameter data
+ * should be sent to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the length specified is less than zero;
- * if the driver does not support national character sets;
- * if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the length specified is less than zero; if
+ * the driver does not support national character sets; if the driver can detect
+ * that a data conversion error could occur; if a database access error occurs
+ * or this method is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
preparedStatement.setNClob(parameterIndex, reader, length);
}
/**
- * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object.
- * The driver converts this to an
- * SQL <code>XML</code> value when it sends it to the database.
+ * Sets the designated parameter to the given <code>java.sql.SQLXML</code>
+ * object. The driver converts this to an SQL <code>XML</code> value when it
+ * sends it to the database.
* <p/>
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
+ * @param xmlObject a <code>SQLXML</code> object that maps an SQL
+ * <code>XML</code> value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code>
- * or the <code>java.xml.transform.Result</code>,
- * <code>Writer</code> or <code>OutputStream</code> has not been closed for
- * the <code>SQLXML</code> object
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code> or the
+ * <code>java.xml.transform.Result</code>, <code>Writer</code> or
+ * <code>OutputStream</code> has not been closed for the <code>SQLXML</code>
+ * object
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
preparedStatement.setSQLXML(parameterIndex, xmlObject);
}
/**
- * 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</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * 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</code> parameter, it may be more practical to send it via a
+ * <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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
+ * @param x the Java input stream that contains the ASCII parameter value
+ * @param length the number of bytes in the stream
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
* @since 1.6
*/
+ @Override
public void setAsciiStream(int parameterIndex, InputStream x, long 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.
- * When a very large binary value is input to a <code>LONGVARBINARY</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the
+ * 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</code> parameter, it may be more practical to send it via
+ * a <code>java.io.InputStream</code> object. The data will be read from the
* stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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
+ * @param x the java input stream which contains the binary parameter value
+ * @param length the number of bytes in the stream
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
* @since 1.6
*/
+ @Override
public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
preparedStatement.setBinaryStream(parameterIndex, x, length);
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object, which
+ * is the given number of characters long. When a very large UNICODE value is
+ * input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
+ * <P>
+ * <B>Note:</B> 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</code> object that contains the
- * Unicode data
- * @param length the number of characters in the stream
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * Unicode data
+ * @param length the number of characters in the stream
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
* @since 1.6
*/
+ @Override
public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
preparedStatement.setCharacterStream(parameterIndex, reader, length);
}
/**
- * Sets the designated parameter to the given input stream.
- * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code>. 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.
+ * Sets the designated parameter to the given input stream. When a very large
+ * ASCII value is input to a <code>LONGVARCHAR</code> parameter, it may be more
+ * practical to send it via a <code>java.io.InputStream</code>. 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setAsciiStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setAsciiStream</code> which takes
+ * a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the Java input stream that contains the ASCII parameter value
+ * @param x the Java input stream that contains the ASCII parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
preparedStatement.setAsciiStream(parameterIndex, x);
}
/**
- * Sets the designated parameter to the given input stream.
- * When a very large binary value is input to a <code>LONGVARBINARY</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.InputStream</code> object. The data will be read from the
- * stream as needed until end-of-file is reached.
+ * Sets the designated parameter to the given input stream. When a very large
+ * binary value is input to a <code>LONGVARBINARY</code> parameter, it may be
+ * more practical to send it via a <code>java.io.InputStream</code> object. The
+ * data will be read from the stream as needed until end-of-file is reached.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setBinaryStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setBinaryStream</code> which
+ * takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param x the java input stream which contains the binary parameter value
+ * @param x the java input stream which contains the binary parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
preparedStatement.setBinaryStream(parameterIndex, x);
}
/**
- * Sets the designated parameter to the given <code>Reader</code>
- * object.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> 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.
+ * Sets the designated parameter to the given <code>Reader</code> object. When a
+ * very large UNICODE value is input to a <code>LONGVARCHAR</code> parameter, it
+ * may be more practical to send it via a <code>java.io.Reader</code> 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><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setCharacterStream</code> which
+ * takes a length parameter.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
- * @param reader the <code>java.io.Reader</code> object that contains the
- * Unicode data
+ * @param reader the <code>java.io.Reader</code> object that contains the
+ * Unicode data
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs or this method
+ * is called on a closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
preparedStatement.setCharacterStream(parameterIndex, reader);
}
/**
* Sets the designated parameter to a <code>Reader</code> object. The
- * <code>Reader</code> reads the data till end-of-file is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
+ * <code>Reader</code> reads the data till end-of-file is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database.
* <p/>
- * <P><B>Note:</B> This stream object can either be a standard
- * Java stream object or your own subclass that implements the
- * standard interface.
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> This stream object can either be a standard Java stream object
+ * or your own subclass that implements the standard interface.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNCharacterStream</code> which
+ * takes a length parameter.
*
* @param parameterIndex of the first parameter is 1, the second is 2, ...
- * @param value the parameter value
+ * @param value the parameter value
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; if a database access error occurs; or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs; or this method is called on a
+ * closed <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
preparedStatement.setNCharacterStream(parameterIndex, value);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be sent to the server as a <code>LONGVARCHAR</code> or a
+ * <code>CLOB</code>
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setClob</code> which takes a
+ * length parameter.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs; this method is called on
- * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
- * marker in the SQL statement
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code>or if parameterIndex does
+ * not correspond to a parameter marker in the SQL statement
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setClob(int parameterIndex, Reader reader) throws SQLException {
preparedStatement.setClob(parameterIndex, reader);
}
/**
- * Sets the designated parameter to a <code>InputStream</code> object.
- * This method differs from the <code>setBinaryStream (int, InputStream)</code>
- * method because it informs the driver that the parameter value should be
- * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
- * the driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
+ * Sets the designated parameter to a <code>InputStream</code> object. This
+ * method differs from the <code>setBinaryStream (int, InputStream)</code>
+ * method because it informs the driver that the parameter value should be sent
+ * to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code>
+ * method is used, the driver may have to do extra work to determine whether the
+ * parameter data should be sent to the server as a <code>LONGVARBINARY</code>
+ * or a <code>BLOB</code>
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setBlob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setBlob</code> which takes a
+ * length parameter.
*
- * @param parameterIndex index of the first parameter is 1,
- * the second is 2, ...
- * @param inputStream An object that contains the data to set the parameter
- * value to.
+ * @param parameterIndex index of the first parameter is 1, the second is 2, ...
+ * @param inputStream An object that contains the data to set the parameter
+ * value to.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement; if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code> or
- * if parameterIndex does not correspond
- * to a parameter marker in the SQL statement,
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if a database access error occurs; this method
+ * is called on a closed <code>PreparedStatement</code> or if parameterIndex
+ * does not correspond to a parameter marker in the SQL statement,
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
preparedStatement.setBlob(parameterIndex, inputStream);
}
/**
- * Sets the designated parameter to a <code>Reader</code> object.
- * This method differs from the <code>setCharacterStream (int, Reader)</code> method
- * because it informs the driver that the parameter value should be sent to
- * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
- * driver may have to do extra work to determine whether the parameter
- * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>setNClob</code> which takes a length parameter.
+ * Sets the designated parameter to a <code>Reader</code> object. This method
+ * differs from the <code>setCharacterStream (int, Reader)</code> method because
+ * it informs the driver that the parameter value should be sent to the server
+ * as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is
+ * used, the driver may have to do extra work to determine whether the parameter
+ * data should be sent to the server as a <code>LONGNVARCHAR</code> or a
+ * <code>NCLOB</code>
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>setNClob</code> which takes a
+ * length parameter.
*
* @param parameterIndex index of the first parameter is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
+ * @param reader An object that contains the data to set the parameter value to.
* @throws SQLException if parameterIndex does not correspond to a parameter
- * marker in the SQL statement;
- * if the driver does not support national character sets;
- * if the driver can detect that a data conversion
- * error could occur; if a database access error occurs or
- * this method is called on a closed <code>PreparedStatement</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * marker in the SQL statement; if the driver does not support national
+ * character sets; if the driver can detect that a data conversion error could
+ * occur; if a database access error occurs or this method is called on a closed
+ * <code>PreparedStatement</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void setNClob(int parameterIndex, Reader reader) throws SQLException {
preparedStatement.setNClob(parameterIndex, reader);
}
/**
- * Retrieves whether this <code>Statement</code> object has been closed. A <code>Statement</code> is closed if the
- * method close has been called on it, or if it is automatically closed.
+ * Retrieves whether this <code>Statement</code> object has been closed. A
+ * <code>Statement</code> is closed if the method close has been called on it,
+ * or if it is automatically closed.
*
- * @return true if this <code>Statement</code> object is closed; false if it is still open
+ * @return true if this <code>Statement</code> object is closed; false if it is
+ * still open
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public boolean isClosed() throws SQLException {
return preparedStatement.isClosed();
}
/**
- * Requests that a <code>Statement</code> be pooled or not pooled. The value
- * specified is a hint to the statement pool implementation indicating
- * whether the applicaiton wants the statement to be pooled. It is up to
- * the statement pool manager as to whether the hint is used.
+ * Requests that a <code>Statement</code> be pooled or not pooled. The value
+ * specified is a hint to the statement pool implementation indicating whether
+ * the applicaiton wants the statement to be pooled. It is up to the statement
+ * pool manager as to whether the hint is used.
* <p/>
- * The poolable value of a statement is applicable to both internal
- * statement caches implemented by the driver and external statement caches
- * implemented by application servers and other applications.
+ * The poolable value of a statement is applicable to both internal statement
+ * caches implemented by the driver and external statement caches implemented by
+ * application servers and other applications.
* <p/>
- * By default, a <code>Statement</code> is not poolable when created, and
- * a <code>PreparedStatement</code> and <code>CallableStatement</code>
- * are poolable when created.
+ * By default, a <code>Statement</code> is not poolable when created, and a
+ * <code>PreparedStatement</code> and <code>CallableStatement</code> are
+ * poolable when created.
* <p/>
*
- * @param poolable requests that the statement be pooled if true and
- * that the statement not be pooled if false
- * <p/>
+ * @param poolable requests that the statement be pooled if true and that the
+ * statement not be pooled if false
+ * <p/>
* @throws SQLException if this method is called on a closed
- * <code>Statement</code>
- * <p/>
+ * <code>Statement</code>
+ * <p/>
* @since 1.6
*/
+ @Override
public void setPoolable(boolean poolable) throws SQLException {
preparedStatement.setPoolable(poolable);
}
/**
- * Returns a value indicating whether the <code>Statement</code>
- * is poolable or not.
+ * Returns a value indicating whether the <code>Statement</code> is poolable or
+ * not.
* <p/>
*
* @throws SQLException if this method is called on a closed
- * <code>Statement</code>
- * <p/>
- * @return <code>true</code> if the <code>Statement</code>
- * is poolable; <code>false</code> otherwise
+ * <code>Statement</code>
+ * <p/>
+ * @return <code>true</code> if the <code>Statement</code> is poolable;
+ * <code>false</code> otherwise
* <p/>
* @see java.sql.Statement#setPoolable(boolean) setPoolable(boolean)
* @since 1.6
- * <p/>
+ * <p/>
*/
+ @Override
public boolean isPoolable() throws SQLException {
return preparedStatement.isPoolable();
}
@@ -556,131 +589,143 @@
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
- T result;
if (iface.isInstance(this)) {
- result = iface.cast(this);
- } else {
- result = preparedStatement.unwrap(iface);
+ return iface.cast(this);
}
- return result;
+
+ return preparedStatement.unwrap(iface);
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
- boolean result;
if (iface.isInstance(this)) {
- result = true;
- } else {
- result = preparedStatement.isWrapperFor(iface);
+ return true;
}
- return result;
+
+ return preparedStatement.isWrapperFor(iface);
}
/**
- * Executes the SQL query in this <code>PreparedStatement</code> object
- * and returns the <code>ResultSet</code> object generated by the query.
+ * Executes the SQL query in this <code>PreparedStatement</code> object and
+ * returns the <code>ResultSet</code> object generated by the query.
*
- * @return a <code>ResultSet</code> object that contains the data produced by the
- * query; never <code>null</code>
- * @throws SQLException if a database access error occurs;
- * this method is called on a closed <code>PreparedStatement</code> or the SQL
- * statement does not return a <code>ResultSet</code> object
+ * @return a <code>ResultSet</code> object that contains the data produced by
+ * the query; never <code>null</code>
+ * @throws SQLException if a database access error occurs; this method is called
+ * on a closed <code>PreparedStatement</code> or the SQL statement does not
+ * return a <code>ResultSet</code> object
*/
- public java.sql.ResultSet executeQuery() throws java.sql.SQLException {
- ResultSet rs = preparedStatement.executeQuery();
+ @Override
+ public ResultSet executeQuery() throws SQLException {
+ ResultSet resultSet = preparedStatement.executeQuery();
incrementResultSetReferenceCount();
- return new ResultSetWrapper40(this, rs);
+ return new ResultSetWrapper40(this, resultSet);
}
/**
* Executes the given SQL statement, which returns a single
* <code>ResultSet</code> object.
*
- * @param sql an SQL statement to be sent to the database, typically a
- * static SQL <code>SELECT</code> statement
- * @return a <code>ResultSet</code> object that contains the data produced
- * by the given query; never <code>null</code>
- * @throws SQLException if a database access error occurs,
- * this method is called on a closed <code>Statement</code> or the given
- * SQL statement produces anything other than a single
- * <code>ResultSet</code> object
+ * @param sql an SQL statement to be sent to the database, typically a static
+ * SQL <code>SELECT</code> statement
+ * @return a <code>ResultSet</code> object that contains the data produced by
+ * the given query; never <code>null</code>
+ * @throws SQLException if a database access error occurs, this method is called
+ * on a closed <code>Statement</code> or the given SQL statement produces
+ * anything other than a single <code>ResultSet</code> object
*/
- public java.sql.ResultSet executeQuery(String sql) throws
- java.sql.SQLException {
- ResultSet rs = preparedStatement.executeQuery(sql);
+ @Override
+ public ResultSet executeQuery(String sql) throws SQLException {
+ ResultSet resultSet = preparedStatement.executeQuery(sql);
incrementResultSetReferenceCount();
- return new ResultSetWrapper40(this, rs);
+ return new ResultSetWrapper40(this, resultSet);
}
/**
* Retrieves any auto-generated keys created as a result of executing this
- * <code>Statement</code> object. If this <code>Statement</code> object did
- * not generate any keys, an empty <code>ResultSet</code>
- * object is returned.
+ * <code>Statement</code> object. If this <code>Statement</code> object did not
+ * generate any keys, an empty <code>ResultSet</code> object is returned.
* <p/>
- * <p><B>Note:</B>If the columns which represent the auto-generated keys were not specified,
- * the JDBC driver implementation will determine the columns which best represent the auto-generated keys.
+ * <p>
+ * <B>Note:</B>If the columns which represent the auto-generated keys were not
+ * specified, the JDBC driver implementation will determine the columns which
+ * best represent the auto-generated keys.
*
* @return a <code>ResultSet</code> object containing the auto-generated key(s)
- * generated by the execution of this <code>Statement</code> object
- * @throws SQLException if a database access error occurs or
- * this method is called on a closed <code>Statement</code>
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * generated by the execution of this <code>Statement</code> object
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed <code>Statement</code>
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
* @since 1.4
*/
- public java.sql.ResultSet getGeneratedKeys() throws java.sql.SQLException {
- ResultSet rs = preparedStatement.getGeneratedKeys();
- if (rs == null)
+ @Override
+ public ResultSet getGeneratedKeys() throws SQLException {
+ ResultSet resultSet = preparedStatement.getGeneratedKeys();
+ if (resultSet == null) {
return null;
+ }
+
incrementResultSetReferenceCount();
- return new ResultSetWrapper40(this, rs);
+ return new ResultSetWrapper40(this, resultSet);
}
/**
- * Retrieves the current result as a <code>ResultSet</code> object.
- * This method should be called only once per result.
+ * Retrieves the current result as a <code>ResultSet</code> object. This method
+ * should be called only once per result.
*
* @return the current result as a <code>ResultSet</code> object or
- * <code>null</code> if the result is an update count or there are no more results
- * @throws SQLException if a database access error occurs or
- * this method is called on a closed <code>Statement</code>
+ * <code>null</code> if the result is an update count or there are no more
+ * results
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed <code>Statement</code>
* @see #execute
*/
- public java.sql.ResultSet getResultSet() throws java.sql.SQLException {
- ResultSet rs = preparedStatement.getResultSet();
- if (rs == null)
+ @Override
+ public ResultSet getResultSet() throws SQLException {
+ ResultSet resultSet = preparedStatement.getResultSet();
+ if (resultSet == null) {
return null;
+ }
+
incrementResultSetReferenceCount();
- return new ResultSetWrapper40(this, rs);
+ return new ResultSetWrapper40(this, resultSet);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ProfiledConnectionWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ProfiledConnectionWrapper40.java
index 64f49be..3a1d222 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ProfiledConnectionWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ProfiledConnectionWrapper40.java
@@ -16,9 +16,9 @@
package com.sun.gjc.spi.jdbc40;
-import com.sun.gjc.spi.ManagedConnectionImpl;
-import com.sun.gjc.spi.base.ConnectionWrapper;
-import com.sun.gjc.util.SQLTraceDelegator;
+import static java.sql.ResultSet.CONCUR_READ_ONLY;
+import static java.sql.ResultSet.TYPE_FORWARD_ONLY;
+
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
@@ -26,11 +26,17 @@
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
-import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
+
import org.glassfish.api.jdbc.SQLTraceRecord;
+import com.sun.gjc.spi.ManagedConnectionImpl;
+import com.sun.gjc.spi.base.ConnectionWrapper;
+import com.sun.gjc.util.SQLTraceDelegator;
+
+import jakarta.resource.spi.ConnectionRequestInfo;
+
/**
* Wrapper class that aids to provide wrapper for Statement, PreparedStatement,
* CallableStatement, DatabaseMetaData. Along with providing a wrapper, this
@@ -44,13 +50,12 @@
/**
* Instantiates connection wrapper to wrap JDBC objects.
+ *
* @param con Connection that is wrapped
- * @param mc Managed Connection
- * @param cxRequestInfo Connection Request Info
+ * @param mc Managed Connection
+ * @param cxRequestInfo Connection Request Info
*/
- public ProfiledConnectionWrapper40(Connection con, ManagedConnectionImpl mc,
- jakarta.resource.spi.ConnectionRequestInfo cxRequestInfo,
- boolean jdbc30Connection, SQLTraceDelegator delegator) {
+ public ProfiledConnectionWrapper40(Connection con, ManagedConnectionImpl mc, ConnectionRequestInfo cxRequestInfo, boolean jdbc30Connection, SQLTraceDelegator delegator) {
super(con, mc, cxRequestInfo, jdbc30Connection);
this.sqlTraceDelegator = delegator;
}
@@ -61,14 +66,13 @@
* @return <code>Statement</code> object.
* @throws java.sql.SQLException In case of a database error.
*/
+ @Override
public Statement createStatement() throws SQLException {
Statement output = null;
- Class intf[] = new Class[]{java.sql.Statement.class};
try {
- output = (java.sql.Statement) getProxyObject(
- new StatementWrapper40(this, super.createStatement()), intf);
+ output = (Statement) getProxyObject(new StatementWrapper40(this, super.createStatement()), new Class<?>[] { Statement.class });
} catch (Exception e) {
- //TODO SQLexception or any other type?
+ // TODO SQLexception or any other type?
throw new SQLException(e);
}
return output;
@@ -77,43 +81,43 @@
/**
* Creates a statement from the underlying Connection.
*
- * @param resultSetType Type of the ResultSet
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code>Statement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
Statement output = null;
- Class intf[] = new Class[]{java.sql.Statement.class};
- try{
- output = (java.sql.Statement)getProxyObject(
- new StatementWrapper40(this,
- super.createStatement(resultSetType, resultSetConcurrency)), intf);
- }catch(Exception e){
+ try {
+ output = (Statement)
+ getProxyObject(
+ new StatementWrapper40(this, super.createStatement(resultSetType, resultSetConcurrency)), new Class<?>[] { Statement.class });
+ } catch (Exception e) {
throw new SQLException(e);
}
+
return output;
}
/**
* Creates a statement from the underlying Connection.
*
- * @param resultSetType Type of the ResultSet
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code>Statement</code> object.
* @throws SQLException In case of a database error.
*/
- public Statement createStatement(int resultSetType, int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
+ @Override
+ public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
Statement output = null;
- Class intf[] = new Class[]{java.sql.Statement.class};
- try{
- output = (java.sql.Statement)getProxyObject(
- new StatementWrapper40(this,
- super.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability)),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { Statement.class };
+ try {
+ output = (Statement)
+ getProxyObject(
+ new StatementWrapper40(this, super.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability)), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
@@ -126,279 +130,269 @@
* @return <code>DatabaseMetaData</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public DatabaseMetaData getMetaData() throws SQLException {
return new DatabaseMetaDataWrapper40(this, super.getMetaData());
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
* @param sql SQL Statement
* @return <code> CallableStatement</code> object.
* @throws java.sql.SQLException In case of a database error.
*/
+ @Override
public CallableStatement prepareCall(String sql) throws SQLException {
CallableStatement output = null;
- Class intf[] = new Class[]{java.sql.CallableStatement.class};
- try{
- output = (java.sql.CallableStatement)getProxyObject(
- mc.prepareCachedCallableStatement(this,sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { java.sql.CallableStatement.class };
+ try {
+ output = (CallableStatement)
+ getProxyObject(
+ managedConnectionImpl.prepareCachedCallableStatement(this, sql, TYPE_FORWARD_ONLY, CONCUR_READ_ONLY), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code> CallableStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public CallableStatement prepareCall(String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
+ @Override
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
CallableStatement output = null;
- Class intf[] = new Class[]{java.sql.CallableStatement.class};
- try{
- output = (java.sql.CallableStatement)getProxyObject(
- mc.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { java.sql.CallableStatement.class };
+ try {
+ output = (CallableStatement)
+ getProxyObject(
+ managedConnectionImpl.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> CallableStatement </code> object for calling database
- * stored procedures.
+ * Creates a <code> CallableStatement </code> object for calling database stored
+ * procedures.
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code> CallableStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public CallableStatement prepareCall(String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
+ @Override
+ public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
CallableStatement output = null;
- Class intf[] = new Class[]{java.sql.CallableStatement.class};
- try{
- output = (java.sql.CallableStatement)getProxyObject(
- mc.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { CallableStatement.class };
+ try {
+ output = (CallableStatement)
+ getProxyObject(
+ managedConnectionImpl.prepareCachedCallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
* @param sql SQL Statement
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public PreparedStatement prepareStatement(String sql) throws SQLException {
PreparedStatement output = null;
- Class intf[] = new Class[]{java.sql.PreparedStatement.class};
+ Class<?>[] intf = new Class[] { PreparedStatement.class };
- try{
- output = (PreparedStatement)getProxyObject(
- mc.prepareCachedStatement(this, sql,
- ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY),
- intf);
- }catch(Exception e){
+ try {
+ output = (PreparedStatement)
+ getProxyObject(
+ managedConnectionImpl.prepareCachedStatement(this, sql, TYPE_FORWARD_ONLY, CONCUR_READ_ONLY), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param autoGeneratedKeys a flag indicating AutoGeneratedKeys need to be returned.
+ * @param sql SQL Statement
+ * @param autoGeneratedKeys a flag indicating AutoGeneratedKeys need to be
+ * returned.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
PreparedStatement output = null;
- Class intf[] = new Class[]{java.sql.PreparedStatement.class};
- try{
- output = (PreparedStatement)getProxyObject(
- mc.prepareCachedStatement(this, sql, autoGeneratedKeys), intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { PreparedStatement.class };
+ try {
+ output = (PreparedStatement)
+ getProxyObject(managedConnectionImpl.prepareCachedStatement(this, sql, autoGeneratedKeys), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param columnIndexes an array of column indexes indicating the columns that should be
- * returned from the inserted row or rows.
+ * @param sql SQL Statement
+ * @param columnIndexes an array of column indexes indicating the columns that
+ * should be returned from the inserted row or rows.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
- PreparedStatement output = null;
- Class intf[] = new Class[]{java.sql.PreparedStatement.class};
- try{
- output = (PreparedStatement)getProxyObject(
- mc.prepareCachedStatement(this, sql, columnIndexes), intf);
- }catch(Exception e){
+ PreparedStatement output = null;
+ Class<?>[] intf = new Class[] { PreparedStatement.class };
+ try {
+ output = (PreparedStatement)
+ getProxyObject(managedConnectionImpl.prepareCachedStatement(this, sql, columnIndexes), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, int resultSetType,
- int resultSetConcurrency) throws SQLException {
+ @Override
+ public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
PreparedStatement output = null;
- Class intf[] = new Class[]{java.sql.PreparedStatement.class};
- try{
- output = (PreparedStatement)getProxyObject(
- mc.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { PreparedStatement.class };
+ try {
+ output = (PreparedStatement)
+ getProxyObject(managedConnectionImpl.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
- * @param resultSetType Type of the ResultSet
+ * @param sql SQL Statement
+ * @param resultSetType Type of the ResultSet
* @param resultSetConcurrency ResultSet Concurrency.
* @param resultSetHoldability ResultSet Holdability.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
- public PreparedStatement prepareStatement(String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability) throws SQLException {
+ @Override
+ public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+ throws SQLException {
PreparedStatement output = null;
- Class intf[] = new Class[]{java.sql.PreparedStatement.class};
- try{
- output = (PreparedStatement)getProxyObject(
- mc.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { PreparedStatement.class };
+ try {
+ output = (PreparedStatement)
+ getProxyObject(
+ managedConnectionImpl.prepareCachedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
/**
- * Creates a <code> PreparedStatement </code> object for sending
- * paramterized SQL statements to database
+ * Creates a <code> PreparedStatement </code> object for sending paramterized
+ * SQL statements to database
*
- * @param sql SQL Statement
+ * @param sql SQL Statement
* @param columnNames Name of bound columns.
* @return <code> PreparedStatement</code> object.
* @throws SQLException In case of a database error.
*/
+ @Override
public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
checkValidity();
jdbcPreInvoke();
PreparedStatement output = null;
- Class intf[] = new Class[]{java.sql.PreparedStatement.class};
- try{
- output = (PreparedStatement)getProxyObject(mc.prepareCachedStatement(this, sql, columnNames),
- intf);
- }catch(Exception e){
+ Class<?>[] intf = new Class[] { PreparedStatement.class };
+ try {
+ output = (PreparedStatement)
+ getProxyObject(managedConnectionImpl.prepareCachedStatement(this, sql, columnNames), intf);
+ } catch (Exception e) {
throw new SQLException(e);
}
return output;
}
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this, super.prepareStatement(sql,
- resultSetType, resultSetConcurrency), enableCaching);
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int resultSetType, int resultSetConcurrency, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, resultSetType, resultSetConcurrency), enableCaching);
}
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- String[] columnNames, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareStatement(sql, columnNames), enableCaching);
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, String[] columnNames, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, columnNames), enableCaching);
}
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency, int resultSetHoldability,
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
+ enableCaching);
+ }
+
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int[] columnIndexes, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, columnIndexes), enableCaching);
+ }
+
+ @Override
+ public PreparedStatementWrapper40 prepareCachedStatement(String sql, int autoGeneratedKeys, boolean enableCaching) throws SQLException {
+ return new PreparedStatementWrapper40(this, super.prepareStatement(sql, autoGeneratedKeys), enableCaching);
+ }
+
+ @Override
+ public CallableStatementWrapper40 callableCachedStatement(String sql, int resultSetType, int resultSetConcurrency,
boolean enableCaching) throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
+ return new CallableStatementWrapper40(this, super.prepareCall(sql, resultSetType, resultSetConcurrency), enableCaching);
+ }
+
+ @Override
+ public CallableStatementWrapper40 callableCachedStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, boolean enableCaching) throws SQLException {
+ return new CallableStatementWrapper40(this, super.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
enableCaching);
}
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int[] columnIndexes, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareStatement(sql, columnIndexes), enableCaching);
- }
-
- public PreparedStatementWrapper40 prepareCachedStatement(String sql,
- int autoGeneratedKeys, boolean enableCaching)
- throws SQLException {
- return new PreparedStatementWrapper40(this,
- super.prepareStatement(sql, autoGeneratedKeys), enableCaching);
- }
-
- public CallableStatementWrapper40 callableCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency, boolean enableCaching)
- throws SQLException {
- return new CallableStatementWrapper40(this, super.prepareCall(sql,
- resultSetType, resultSetConcurrency), enableCaching);
- }
-
- public CallableStatementWrapper40 callableCachedStatement(String sql,
- int resultSetType, int resultSetConcurrency,
- int resultSetHoldability, boolean enableCaching)
- throws SQLException {
- return new CallableStatementWrapper40(this, super.prepareCall(sql,
- resultSetType, resultSetConcurrency, resultSetHoldability),
- enableCaching);
- }
-
- //TODO refactor this method and move to a higher level
- private <T> T getProxyObject(final Object actualObject, Class<T>[] ifaces) throws Exception {
-
- T result;
+ // TODO refactor this method and move to a higher level
+ @SuppressWarnings("unchecked")
+ private <T> T getProxyObject(final Object actualObject, Class<?>[] ifaces) throws Exception {
InvocationHandler ih = new InvocationHandler() {
+ @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SQLTraceRecord record = new SQLTraceRecord();
record.setMethodName(method.getName());
@@ -411,8 +405,8 @@
return method.invoke(actualObject, args);
}
};
- result = (T) Proxy.newProxyInstance(actualObject.getClass().getClassLoader(), ifaces, ih);
- return result;
+
+ return (T) Proxy.newProxyInstance(actualObject.getClass().getClassLoader(), ifaces, ih);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ResultSetWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ResultSetWrapper40.java
index 9a479f3..c54f7ed 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ResultSetWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/ResultSetWrapper40.java
@@ -16,16 +16,23 @@
package com.sun.gjc.spi.jdbc40;
-import com.sun.enterprise.util.i18n.StringManager;
-import com.sun.gjc.common.DataSourceObjectBuilder;
-import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
-import com.sun.gjc.spi.base.ResultSetWrapper;
+import static com.sun.gjc.common.DataSourceObjectBuilder.isJDBC41;
+import static java.util.logging.Level.SEVERE;
import java.io.InputStream;
import java.io.Reader;
+import java.sql.NClob;
+import java.sql.ResultSet;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.SQLXML;
+import java.sql.Statement;
-import java.sql.*;
-import java.util.logging.Level;
+import com.sun.enterprise.util.i18n.StringManager;
+import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
+import com.sun.gjc.spi.base.ResultSetWrapper;
+
import jakarta.resource.ResourceException;
/**
@@ -33,104 +40,108 @@
*/
public class ResultSetWrapper40 extends ResultSetWrapper {
- protected final static StringManager localStrings =
- StringManager.getManager(ManagedConnectionFactoryImpl.class);
+ protected final static StringManager localStrings = StringManager.getManager(ManagedConnectionFactoryImpl.class);
/**
* Creates a new instance of ResultSetWrapper for JDBC 4.0
*
- * @param stmt Statement that is to be wrapped<br>
- * @param rs ResultSet that is to be wraped<br>*
+ * @param statement Statement that is to be wrapped<br>
+ * @param resultSet ResultSet that is to be wraped<br>
+ * *
*/
- public ResultSetWrapper40(Statement stmt, ResultSet rs) {
- super(stmt, rs);
+ public ResultSetWrapper40(Statement statement, ResultSet resultSet) {
+ super(statement, resultSet);
}
/**
* Retrieves the value of the designated column in the current row of this
- * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the Java
- * programming language.
+ * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the
+ * Java programming language.
*
* @param columnIndex the first column is 1, the second 2, ...
- * @return the column value; if the value is a SQL <code>NULL</code> the
- * value returned is <code>null</code>
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @return the column value; if the value is a SQL <code>NULL</code> the value
+ * returned is <code>null</code>
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public RowId getRowId(int columnIndex) throws SQLException {
return resultSet.getRowId(columnIndex);
}
/**
* Retrieves the value of the designated column in the current row of this
- * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the Java
- * programming language.
+ * <code>ResultSet</code> object as a <code>java.sql.RowId</code> object in the
+ * Java programming language.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @return the column value ; if the value is a SQL <code>NULL</code> the
- * value returned is <code>null</code>
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @return the column value ; if the value is a SQL <code>NULL</code> the value
+ * returned is <code>null</code>
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public RowId getRowId(String columnLabel) throws SQLException {
return resultSet.getRowId(columnLabel);
}
+ @SuppressWarnings("unchecked")
+ @Override
public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- Class<?>[] valueTypes = new Class<?>[]{Integer.TYPE, Class.class};
- try {
- return (T) getMethodExecutor().invokeMethod(resultSet, "getObject", valueTypes, columnIndex, type);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_get_object", ex);
- throw new SQLException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ Class<?>[] valueTypes = new Class<?>[] { Integer.TYPE, Class.class };
+ try {
+ return (T) getMethodExecutor().invokeMethod(resultSet, "getObject", valueTypes, columnIndex, type);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_get_object", ex);
+ throw new SQLException(ex);
+ }
}
+ @SuppressWarnings("unchecked")
+ @Override
public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
- if (DataSourceObjectBuilder.isJDBC41()) {
- Class<?>[] valueTypes = new Class<?>[]{String.class, Class.class};
- try {
- return (T) getMethodExecutor().invokeMethod(resultSet, "getObject", valueTypes, columnLabel, type);
- } catch (ResourceException ex) {
- _logger.log(Level.SEVERE, "jdbc.ex_get_object", ex);
- throw new SQLException(ex);
- }
+ if (!isJDBC41()) {
+ throw new UnsupportedOperationException("Operation not supported in this runtime.");
}
- throw new UnsupportedOperationException("Operation not supported in this runtime.");
+
+ Class<?>[] valueTypes = new Class<?>[] { String.class, Class.class };
+ try {
+ return (T) getMethodExecutor().invokeMethod(resultSet, "getObject", valueTypes, columnLabel, type);
+ } catch (ResourceException ex) {
+ _logger.log(SEVERE, "jdbc.ex_get_object", ex);
+ throw new SQLException(ex);
+ }
}
/**
* Updates the designated column with a <code>RowId</code> value. The updater
* methods are used to update column values in the current row or the insert
- * row. The updater methods do not update the underlying database; instead
- * the <code>updateRow</code> or <code>insertRow</code> methods are called
- * to update the database.
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
* @param columnIndex the first column is 1, the second 2, ...
- * @param x the column value
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the column value
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateRowId(int columnIndex, RowId x) throws SQLException {
resultSet.updateRowId(columnIndex, x);
}
@@ -138,22 +149,22 @@
/**
* Updates the designated column with a <code>RowId</code> value. The updater
* methods are used to update column values in the current row or the insert
- * row. The updater methods do not update the underlying database; instead
- * the <code>updateRow</code> or <code>insertRow</code> methods are called
- * to update the database.
+ * row. The updater methods do not update the underlying database; instead the
+ * <code>updateRow</code> or <code>insertRow</code> methods are called to update
+ * the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was
- * not specified, then the label is the name of the column
- * @param x the column value
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param x the column value
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateRowId(String columnLabel, RowId x) throws SQLException {
resultSet.updateRowId(columnLabel, x);
}
@@ -161,476 +172,457 @@
/**
* Retrieves the holdability of this <code>ResultSet</code> object
*
- * @return either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
- * @throws SQLException if a database access error occurs
- * or this method is called on a closed result set
+ * @return either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
+ * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed result set
* @since 1.6
*/
+ @Override
public int getHoldability() throws SQLException {
return resultSet.getHoldability();
}
/**
- * Retrieves whether this <code>ResultSet</code> object has been closed. A <code>ResultSet</code> is closed if the
- * method close has been called on it, or if it is automatically closed.
+ * Retrieves whether this <code>ResultSet</code> object has been closed. A
+ * <code>ResultSet</code> is closed if the method close has been called on it,
+ * or if it is automatically closed.
*
- * @return true if this <code>ResultSet</code> object is closed; false if it is still open
+ * @return true if this <code>ResultSet</code> object is closed; false if it is
+ * still open
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public boolean isClosed() throws SQLException {
return resultSet.isClosed();
}
/**
- * Updates the designated column with a <code>String</code> value.
- * It is intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
+ * Updates the designated column with a <code>String</code> value. It is
+ * intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> columns. The updater methods are used to update
+ * column values in the current row or the insert row. The updater methods do
+ * not update the underlying database; instead the <code>updateRow</code> or
* <code>insertRow</code> methods are called to update the database.
*
* @param columnIndex the first column is 1, the second 2, ...
- * @param nString the value for the column to be updated
- * @throws SQLException if the columnIndex is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or if a database access error occurs
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param nString the value for the column to be updated
+ * @throws SQLException if the columnIndex is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set;
+ * the result set concurrency is <code>CONCUR_READ_ONLY</code> or if a database
+ * access error occurs
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNString(int columnIndex, String nString) throws SQLException {
resultSet.updateNString(columnIndex, nString);
}
/**
- * Updates the designated column with a <code>String</code> value.
- * It is intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
+ * Updates the designated column with a <code>String</code> value. It is
+ * intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> columns. The updater methods are used to update
+ * column values in the current row or the insert row. The updater methods do
+ * not update the underlying database; instead the <code>updateRow</code> or
* <code>insertRow</code> methods are called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param nString the value for the column to be updated
- * @throws SQLException if the columnLabel is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set;
- * the result set concurrency is <CODE>CONCUR_READ_ONLY</code>
- * or if a database access error occurs
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param nString the value for the column to be updated
+ * @throws SQLException if the columnLabel is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set;
+ * the result set concurrency is <CODE>CONCUR_READ_ONLY</code> or if a database
+ * access error occurs
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNString(String columnLabel, String nString) throws SQLException {
resultSet.updateNString(columnLabel, nString);
}
/**
- * Updates the designated column with a <code>java.sql.NClob</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.NClob</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second 2, ...
- * @param nClob the value for the column to be updated
- * @throws SQLException if the columnIndex is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set;
- * if a database access error occurs or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param nClob the value for the column to be updated
+ * @throws SQLException if the columnIndex is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set;
+ * if a database access error occurs or the result set concurrency is
+ * <code>CONCUR_READ_ONLY</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
resultSet.updateNClob(columnIndex, nClob);
}
/**
- * Updates the designated column with a <code>java.sql.NClob</code> value.
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * Updates the designated column with a <code>java.sql.NClob</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param nClob the value for the column to be updated
- * @throws SQLException if the columnLabel is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set;
- * if a database access error occurs or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param nClob the value for the column to be updated
+ * @throws SQLException if the columnLabel is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set;
+ * if a database access error occurs or the result set concurrency is
+ * <code>CONCUR_READ_ONLY</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
resultSet.updateNClob(columnLabel, nClob);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>NClob</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>NClob</code> object in the Java
+ * programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return a <code>NClob</code> object representing the SQL
- * <code>NCLOB</code> value in the specified column
- * @throws SQLException if the columnIndex is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set
- * or if a database access error occurs
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
+ * value in the specified column
+ * @throws SQLException if the columnIndex is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set or
+ * if a database access error occurs
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public NClob getNClob(int columnIndex) throws SQLException {
return resultSet.getNClob(columnIndex);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a <code>NClob</code> object
- * in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>NClob</code> object in the Java
+ * programming language.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
* @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
- * value in the specified column
- * @throws SQLException if the columnLabel is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set
- * or if a database access error occurs
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * value in the specified column
+ * @throws SQLException if the columnLabel is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set or
+ * if a database access error occurs
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public NClob getNClob(String columnLabel) throws SQLException {
return resultSet.getNClob(columnLabel);
}
/**
- * Retrieves the value of the designated column in the current row of
- * this <code>ResultSet</code> as a
- * <code>java.sql.SQLXML</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> as a <code>java.sql.SQLXML</code> object in the Java
+ * programming language.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public SQLXML getSQLXML(int columnIndex) throws SQLException {
return resultSet.getSQLXML(columnIndex);
}
/**
- * Retrieves the value of the designated column in the current row of
- * this <code>ResultSet</code> as a
- * <code>java.sql.SQLXML</code> object in the Java programming language.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> as a <code>java.sql.SQLXML</code> object in the Java
+ * programming language.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
* @return a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public SQLXML getSQLXML(String columnLabel) throws SQLException {
return resultSet.getSQLXML(columnLabel);
}
/**
- * Updates the designated column with a <code>java.sql.SQLXML</code> value.
- * The updater
- * methods are used to update column values in the current row or the insert
- * row. The updater methods do not update the underlying database; instead
- * the <code>updateRow</code> or <code>insertRow</code> methods are called
- * to update the database.
+ * Updates the designated column with a <code>java.sql.SQLXML</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
*
* @param columnIndex the first column is 1, the second 2, ...
- * @param xmlObject the value for the column to be updated
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs; this method
- * is called on a closed result set;
- * the <code>java.xml.transform.Result</code>,
- * <code>Writer</code> or <code>OutputStream</code> has not been closed
- * for the <code>SQLXML</code> object;
- * if there is an error processing the XML value or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code> method
- * of the exception may provide a more detailed exception, for example, if the
- * stream does not contain valid XML.
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param xmlObject the value for the column to be updated
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; this method is called on a closed result set; the
+ * <code>java.xml.transform.Result</code>, <code>Writer</code> or
+ * <code>OutputStream</code> has not been closed for the <code>SQLXML</code>
+ * object; if there is an error processing the XML value or the result set
+ * concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code>
+ * method of the exception may provide a more detailed exception, for example,
+ * if the stream does not contain valid XML.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
resultSet.updateSQLXML(columnIndex, xmlObject);
}
/**
- * Updates the designated column with a <code>java.sql.SQLXML</code> value.
- * The updater
- * methods are used to update column values in the current row or the insert
- * row. The updater methods do not update the underlying database; instead
- * the <code>updateRow</code> or <code>insertRow</code> methods are called
- * to update the database.
+ * Updates the designated column with a <code>java.sql.SQLXML</code> value. The
+ * updater methods are used to update column values in the current row or the
+ * insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param xmlObject the column value
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs; this method
- * is called on a closed result set;
- * the <code>java.xml.transform.Result</code>,
- * <code>Writer</code> or <code>OutputStream</code> has not been closed
- * for the <code>SQLXML</code> object;
- * if there is an error processing the XML value or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code> method
- * of the exception may provide a more detailed exception, for example, if the
- * stream does not contain valid XML.
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param xmlObject the column value
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; this method is called on a closed result set; the
+ * <code>java.xml.transform.Result</code>, <code>Writer</code> or
+ * <code>OutputStream</code> has not been closed for the <code>SQLXML</code>
+ * object; if there is an error processing the XML value or the result set
+ * concurrency is <code>CONCUR_READ_ONLY</code>. The <code>getCause</code>
+ * method of the exception may provide a more detailed exception, for example,
+ * if the stream does not contain valid XML.
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
resultSet.updateSQLXML(columnLabel, xmlObject);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>String</code> in the Java programming language.
- * It is intended for use when
- * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>String</code> in the Java
+ * programming language. It is intended for use when accessing
+ * <code>NCHAR</code>,<code>NVARCHAR</code> and <code>LONGNVARCHAR</code>
+ * columns.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public String getNString(int columnIndex) throws SQLException {
return resultSet.getNString(columnIndex);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as
- * a <code>String</code> in the Java programming language.
- * It is intended for use when
- * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>String</code> in the Java
+ * programming language. It is intended for use when accessing
+ * <code>NCHAR</code>,<code>NVARCHAR</code> and <code>LONGNVARCHAR</code>
+ * columns.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @return the column value; if the value is SQL <code>NULL</code>, the
- * value returned is <code>null</code>
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @return the column value; if the value is SQL <code>NULL</code>, the value
+ * returned is <code>null</code>
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public String getNString(String columnLabel) throws SQLException {
return resultSet.getNString(columnLabel);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a
- * <code>java.io.Reader</code> object.
- * It is intended for use when
- * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.io.Reader</code> object. It is
+ * intended for use when accessing <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> columns.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @return a <code>java.io.Reader</code> object that contains the column
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language.
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @return a <code>java.io.Reader</code> object that contains the column value;
+ * if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language.
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public Reader getNCharacterStream(int columnIndex) throws SQLException {
return resultSet.getNCharacterStream(columnIndex);
}
/**
- * Retrieves the value of the designated column in the current row
- * of this <code>ResultSet</code> object as a
- * <code>java.io.Reader</code> object.
- * It is intended for use when
- * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * Retrieves the value of the designated column in the current row of this
+ * <code>ResultSet</code> object as a <code>java.io.Reader</code> object. It is
+ * intended for use when accessing <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> columns.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @return a <code>java.io.Reader</code> object that contains the column
- * value; if the value is SQL <code>NULL</code>, the value returned is
- * <code>null</code> in the Java programming language
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @return a <code>java.io.Reader</code> object that contains the column value;
+ * if the value is SQL <code>NULL</code>, the value returned is
+ * <code>null</code> in the Java programming language
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs or this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public Reader getNCharacterStream(String columnLabel) throws SQLException {
return resultSet.getNCharacterStream(columnLabel);
}
/**
* Updates the designated column with a character stream value, which will have
- * the specified number of bytes. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
- * It is intended for use when
- * updating <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * the specified number of bytes. The driver does the necessary conversion from
+ * Java character format to the national character set in the database. It is
+ * intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> columns.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
resultSet.updateNCharacterStream(columnIndex, x, length);
}
/**
* Updates the designated column with a character stream value, which will have
- * the specified number of bytes. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
- * It is intended for use when
- * updating <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * the specified number of bytes. The driver does the necessary conversion from
+ * Java character format to the national character set in the database. It is
+ * intended for use when updating <code>NCHAR</code>,<code>NVARCHAR</code> and
+ * <code>LONGNVARCHAR</code> columns.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader the <code>java.io.Reader</code> object containing
- * the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader the <code>java.io.Reader</code> object containing the new
+ * column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
resultSet.updateNCharacterStream(columnLabel, reader, length);
}
/**
- * Updates the designated column with an ascii stream value, which will have
- * the specified number of bytes.
+ * Updates the designated column with an ascii stream value, which will have the
+ * specified number of bytes.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
resultSet.updateAsciiStream(columnIndex, x, length);
}
/**
- * Updates the designated column with a binary stream value, which will have
- * the specified number of bytes.
+ * Updates the designated column with a binary stream value, which will have the
+ * specified number of bytes.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
resultSet.updateBinaryStream(columnIndex, x, length);
}
@@ -639,75 +631,74 @@
* Updates the designated column with a character stream value, which will have
* the specified number of bytes.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
resultSet.updateCharacterStream(columnIndex, x, length);
}
/**
- * Updates the designated column with an ascii stream value, which will have
- * the specified number of bytes.
+ * Updates the designated column with an ascii stream value, which will have the
+ * specified number of bytes.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param x the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param x the new column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
resultSet.updateAsciiStream(columnLabel, x, length);
}
/**
- * Updates the designated column with a binary stream value, which will have
- * the specified number of bytes.
+ * Updates the designated column with a binary stream value, which will have the
+ * specified number of bytes.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param x the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param x the new column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
resultSet.updateBinaryStream(columnLabel, x, length);
}
@@ -716,572 +707,565 @@
* Updates the designated column with a character stream value, which will have
* the specified number of bytes.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader the <code>java.io.Reader</code> object containing
- * the new column value
- * @param length the length of the stream
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader the <code>java.io.Reader</code> object containing the new
+ * column value
+ * @param length the length of the stream
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
resultSet.updateCharacterStream(columnLabel, reader, length);
}
/**
- * Updates the designated column using the given input stream, which
- * will have the specified number of bytes.
+ * Updates the designated column using the given input stream, which will have
+ * the specified number of bytes.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param inputStream An object that contains the data to set the parameter
- * value to.
- * @param length the number of bytes in the parameter data.
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * value to.
+ * @param length the number of bytes in the parameter data.
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
resultSet.updateBlob(columnIndex, inputStream, length);
}
/**
- * Updates the designated column using the given input stream, which
- * will have the specified number of bytes.
+ * Updates the designated column using the given input stream, which will have
+ * the specified number of bytes.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
* @param inputStream An object that contains the data to set the parameter
- * value to.
- * @param length the number of bytes in the parameter data.
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * value to.
+ * @param length the number of bytes in the parameter data.
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
resultSet.updateBlob(columnLabel, inputStream, length);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> object. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object,
+ * which is the given number of characters long. When a very large UNICODE value
+ * is input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> object. The JDBC driver will do any
+ * necessary conversion from UNICODE to the database char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
resultSet.updateClob(columnIndex, reader, length);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> object. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object,
+ * which is the given number of characters long. When a very large UNICODE value
+ * is input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> object. The JDBC driver will do any
+ * necessary conversion from UNICODE to the database char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was
- * not specified, then the label is the name of the column
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
resultSet.updateClob(columnLabel, reader, length);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> object. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object,
+ * which is the given number of characters long. When a very large UNICODE value
+ * is input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> object. The JDBC driver will do any
+ * necessary conversion from UNICODE to the database char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
* @param columnIndex the first column is 1, the second 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
- * @throws SQLException if the columnIndex is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set,
- * if a database access error occurs or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
+ * @throws SQLException if the columnIndex is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set,
+ * if a database access error occurs or the result set concurrency is
+ * <code>CONCUR_READ_ONLY</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
resultSet.updateNClob(columnIndex, reader, length);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object, which is the given number of characters long.
- * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
- * parameter, it may be more practical to send it via a
- * <code>java.io.Reader</code> object. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object,
+ * which is the given number of characters long. When a very large UNICODE value
+ * is input to a <code>LONGVARCHAR</code> parameter, it may be more practical to
+ * send it via a <code>java.io.Reader</code> object. The JDBC driver will do any
+ * necessary conversion from UNICODE to the database char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader An object that contains the data to set the parameter value to.
- * @param length the number of characters in the parameter data.
- * @throws SQLException if the columnLabel is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set;
- * if a database access error occurs or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader An object that contains the data to set the parameter value to.
+ * @param length the number of characters in the parameter data.
+ * @throws SQLException if the columnLabel is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set;
+ * if a database access error occurs or the result set concurrency is
+ * <code>CONCUR_READ_ONLY</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
resultSet.updateNClob(columnLabel, reader, length);
}
/**
- * Updates the designated column with a character stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
- * It is intended for use when
- * updating <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * Updates the designated column with a character stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database. It is intended for use when updating
+ * <code>NCHAR</code>,<code>NVARCHAR</code> and <code>LONGNVARCHAR</code>
+ * columns.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateNCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateNCharacterStream</code>
+ * which takes a length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
resultSet.updateNCharacterStream(columnIndex, x);
}
/**
- * Updates the designated column with a character stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached. The
- * driver does the necessary conversion from Java character format to
- * the national character set in the database.
- * It is intended for use when
- * updating <code>NCHAR</code>,<code>NVARCHAR</code>
- * and <code>LONGNVARCHAR</code> columns.
+ * Updates the designated column with a character stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached. The driver
+ * does the necessary conversion from Java character format to the national
+ * character set in the database. It is intended for use when updating
+ * <code>NCHAR</code>,<code>NVARCHAR</code> and <code>LONGNVARCHAR</code>
+ * columns.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateNCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateNCharacterStream</code>
+ * which takes a length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader the <code>java.io.Reader</code> object containing
- * the new column value
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader the <code>java.io.Reader</code> object containing the new
+ * column value
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
resultSet.updateNCharacterStream(columnLabel, reader);
}
/**
- * Updates the designated column with an ascii stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column with an ascii stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateAsciiStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateAsciiStream</code> which
+ * takes a length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
resultSet.updateAsciiStream(columnIndex, x);
}
/**
- * Updates the designated column with a binary stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column with a binary stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateBinaryStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateBinaryStream</code> which
+ * takes a length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
resultSet.updateBinaryStream(columnIndex, x);
}
/**
- * Updates the designated column with a character stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column with a character stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateCharacterStream</code>
+ * which takes a length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param x the new column value
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param x the new column value
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
resultSet.updateCharacterStream(columnIndex, x);
}
/**
- * Updates the designated column with an ascii stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column with an ascii stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateAsciiStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateAsciiStream</code> which
+ * takes a length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param x the new column value
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param x the new column value
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
resultSet.updateAsciiStream(columnLabel, x);
}
/**
- * Updates the designated column with a binary stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column with a binary stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateBinaryStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateBinaryStream</code> which
+ * takes a length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param x the new column value
- * @throws SQLException if the columnLabel is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param x the new column value
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
resultSet.updateBinaryStream(columnLabel, x);
}
/**
- * Updates the designated column with a character stream value.
- * The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column with a character stream value. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateCharacterStream</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateCharacterStream</code>
+ * which takes a length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader the <code>java.io.Reader</code> object containing
- * the new column value
- * @throws SQLException if the columnLabel is not valid; if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader the <code>java.io.Reader</code> object containing the new
+ * column value
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
resultSet.updateCharacterStream(columnLabel, reader);
}
/**
- * Updates the designated column using the given input stream. The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column using the given input stream. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateBlob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateBlob</code> which takes a
+ * length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param inputStream An object that contains the data to set the parameter
- * value to.
- * @throws SQLException if the columnIndex is not valid; if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * value to.
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
resultSet.updateBlob(columnIndex, inputStream);
}
/**
- * Updates the designated column using the given input stream. The data will be read from the stream
- * as needed until end-of-stream is reached.
+ * Updates the designated column using the given input stream. The data will be
+ * read from the stream as needed until end-of-stream is reached.
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateBlob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateBlob</code> which takes a
+ * length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
* @param inputStream An object that contains the data to set the parameter
- * value to.
- * @throws SQLException if the columnLabel is not valid; if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * value to.
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
resultSet.updateBlob(columnLabel, inputStream);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object.
- * The data will be read from the stream
- * as needed until end-of-stream is reached. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object. The
+ * data will be read from the stream as needed until end-of-stream is reached.
+ * The JDBC driver will do any necessary conversion from UNICODE to the database
+ * char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateClob</code> which takes a
+ * length parameter.
*
* @param columnIndex the first column is 1, the second is 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @throws SQLException if the columnIndex is not valid;
- * if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param reader An object that contains the data to set the parameter value to.
+ * @throws SQLException if the columnIndex is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateClob(int columnIndex, Reader reader) throws SQLException {
resultSet.updateClob(columnIndex, reader);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object.
- * The data will be read from the stream
- * as needed until end-of-stream is reached. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object. The
+ * data will be read from the stream as needed until end-of-stream is reached.
+ * The JDBC driver will do any necessary conversion from UNICODE to the database
+ * char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateClob</code> which takes a
+ * length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader An object that contains the data to set the parameter value to.
- * @throws SQLException if the columnLabel is not valid; if a database access error occurs;
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * or this method is called on a closed result set
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader An object that contains the data to set the parameter value to.
+ * @throws SQLException if the columnLabel is not valid; if a database access
+ * error occurs; the result set concurrency is <code>CONCUR_READ_ONLY</code> or
+ * this method is called on a closed result set
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateClob(String columnLabel, Reader reader) throws SQLException {
resultSet.updateClob(columnLabel, reader);
}
@@ -1289,67 +1273,68 @@
/**
* Updates the designated column using the given <code>Reader</code>
* <p/>
- * The data will be read from the stream
- * as needed until end-of-stream is reached. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * The data will be read from the stream as needed until end-of-stream is
+ * reached. The JDBC driver will do any necessary conversion from UNICODE to the
+ * database char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateNClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateNClob</code> which takes a
+ * length parameter.
*
* @param columnIndex the first column is 1, the second 2, ...
- * @param reader An object that contains the data to set the parameter value to.
- * @throws SQLException if the columnIndex is not valid;
- * if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set,
- * if a database access error occurs or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param reader An object that contains the data to set the parameter value to.
+ * @throws SQLException if the columnIndex is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set,
+ * if a database access error occurs or the result set concurrency is
+ * <code>CONCUR_READ_ONLY</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNClob(int columnIndex, Reader reader) throws SQLException {
resultSet.updateNClob(columnIndex, reader);
}
/**
- * Updates the designated column using the given <code>Reader</code>
- * object.
- * The data will be read from the stream
- * as needed until end-of-stream is reached. The JDBC driver will
- * do any necessary conversion from UNICODE to the database char format.
+ * Updates the designated column using the given <code>Reader</code> object. The
+ * data will be read from the stream as needed until end-of-stream is reached.
+ * The JDBC driver will do any necessary conversion from UNICODE to the database
+ * char format.
* <p/>
* <p/>
- * The updater methods are used to update column values in the
- * current row or the insert row. The updater methods do not
- * update the underlying database; instead the <code>updateRow</code> or
- * <code>insertRow</code> methods are called to update the database.
+ * The updater methods are used to update column values in the current row or
+ * the insert row. The updater methods do not update the underlying database;
+ * instead the <code>updateRow</code> or <code>insertRow</code> methods are
+ * called to update the database.
* <p/>
- * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
- * it might be more efficient to use a version of
- * <code>updateNClob</code> which takes a length parameter.
+ * <P>
+ * <B>Note:</B> Consult your JDBC driver documentation to determine if it might
+ * be more efficient to use a version of <code>updateNClob</code> which takes a
+ * length parameter.
*
- * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not
- * specified, then the label is the name of the column
- * @param reader An object that contains the data to set the parameter value to.
- * @throws SQLException if the columnLabel is not valid; if the driver does not support national
- * character sets; if the driver can detect that a data conversion
- * error could occur; this method is called on a closed result set;
- * if a database access error occurs or
- * the result set concurrency is <code>CONCUR_READ_ONLY</code>
- * @throws SQLFeatureNotSupportedException
- * if the JDBC driver does not support
- * this method
+ * @param columnLabel the label for the column specified with the SQL AS clause.
+ * If the SQL AS clause was not specified, then the label is the name of the
+ * column
+ * @param reader An object that contains the data to set the parameter value to.
+ * @throws SQLException if the columnLabel is not valid; if the driver does not
+ * support national character sets; if the driver can detect that a data
+ * conversion error could occur; this method is called on a closed result set;
+ * if a database access error occurs or the result set concurrency is
+ * <code>CONCUR_READ_ONLY</code>
+ * @throws SQLFeatureNotSupportedException if the JDBC driver does not support
+ * this method
* @since 1.6
*/
+ @Override
public void updateNClob(String columnLabel, Reader reader) throws SQLException {
resultSet.updateNClob(columnLabel, reader);
}
@@ -1358,51 +1343,55 @@
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
- T result;
if (iface.isInstance(this)) {
- result = iface.cast(this);
- } else {
- result = resultSet.unwrap(iface);
+ return iface.cast(this);
}
- return result;
+
+ return resultSet.unwrap(iface);
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
- boolean result;
if (iface.isInstance(this)) {
- result = true;
- } else {
- result = resultSet.isWrapperFor(iface);
+ return true;
}
- return result;
+
+ return resultSet.isWrapperFor(iface);
}
}
diff --git a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/StatementWrapper40.java b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/StatementWrapper40.java
index 266a7e5..0be14f1 100644
--- a/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/StatementWrapper40.java
+++ b/appserver/jdbc/jdbc-ra/jdbc40/src/main/java/com/sun/gjc/spi/jdbc40/StatementWrapper40.java
@@ -16,24 +16,26 @@
package com.sun.gjc.spi.jdbc40;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.gjc.spi.ManagedConnectionFactoryImpl;
import com.sun.gjc.spi.base.StatementWrapper;
-import java.sql.*;
-
/**
* Wrapper for JDBC 4.0 Statement
*/
public class StatementWrapper40 extends StatementWrapper {
- protected final static StringManager localStrings =
- StringManager.getManager(ManagedConnectionFactoryImpl.class);
+ protected final static StringManager localStrings = StringManager.getManager(ManagedConnectionFactoryImpl.class);
/**
* Creates a new instance of StatementWrapper for JDBC 3.0<br>
*
- * @param con ConnectionWrapper <br>
+ * @param con ConnectionWrapper <br>
* @param statement Statement that is to be wrapped<br>
*/
public StatementWrapper40(Connection con, Statement statement) {
@@ -41,59 +43,64 @@
}
/**
- * Retrieves whether this <code>Statement</code> object has been closed. A <code>Statement</code> is closed if the
- * method close has been called on it, or if it is automatically closed.
+ * Retrieves whether this <code>Statement</code> object has been closed. A
+ * <code>Statement</code> is closed if the method close has been called on it,
+ * or if it is automatically closed.
*
- * @return true if this <code>Statement</code> object is closed; false if it is still open
+ * @return true if this <code>Statement</code> object is closed; false if it is
+ * still open
* @throws SQLException if a database access error occurs
* @since 1.6
*/
+ @Override
public boolean isClosed() throws SQLException {
return jdbcStatement.isClosed();
}
/**
- * Requests that a <code>Statement</code> be pooled or not pooled. The value
- * specified is a hint to the statement pool implementation indicating
- * whether the applicaiton wants the statement to be pooled. It is up to
- * the statement pool manager as to whether the hint is used.
+ * Requests that a <code>Statement</code> be pooled or not pooled. The value
+ * specified is a hint to the statement pool implementation indicating whether
+ * the application wants the statement to be pooled. It is up to the statement
+ * pool manager as to whether the hint is used.
* <p/>
- * The poolable value of a statement is applicable to both internal
- * statement caches implemented by the driver and external statement caches
- * implemented by application servers and other applications.
+ * The poolable value of a statement is applicable to both internal statement
+ * caches implemented by the driver and external statement caches implemented by
+ * application servers and other applications.
* <p/>
- * By default, a <code>Statement</code> is not poolable when created, and
- * a <code>PreparedStatement</code> and <code>CallableStatement</code>
- * are poolable when created.
+ * By default, a <code>Statement</code> is not poolable when created, and a
+ * <code>PreparedStatement</code> and <code>CallableStatement</code> are
+ * poolable when created.
* <p/>
*
- * @param poolable requests that the statement be pooled if true and
- * that the statement not be pooled if false
- * <p/>
+ * @param poolable requests that the statement be pooled if true and that the
+ * statement not be pooled if false
+ * <p/>
* @throws SQLException if this method is called on a closed
- * <code>Statement</code>
- * <p/>
+ * <code>Statement</code>
+ * <p/>
* @since 1.6
*/
+ @Override
public void setPoolable(boolean poolable) throws SQLException {
jdbcStatement.setPoolable(poolable);
}
/**
- * Returns a value indicating whether the <code>Statement</code>
- * is poolable or not.
+ * Returns a value indicating whether the <code>Statement</code> is poolable or
+ * not.
* <p/>
*
* @throws SQLException if this method is called on a closed
- * <code>Statement</code>
- * <p/>
- * @return <code>true</code> if the <code>Statement</code>
- * is poolable; <code>false</code> otherwise
+ * <code>Statement</code>
+ * <p/>
+ * @return <code>true</code> if the <code>Statement</code> is poolable;
+ * <code>false</code> otherwise
* <p/>
* @see java.sql.Statement#setPoolable(boolean) setPoolable(boolean)
* @since 1.6
- * <p/>
+ * <p/>
*/
+ @Override
public boolean isPoolable() throws SQLException {
return jdbcStatement.isPoolable();
}
@@ -102,19 +109,22 @@
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
* <p/>
- * If the receiver implements the interface then the result is the receiver
- * or a proxy for the receiver. If the receiver is a wrapper
- * and the wrapped object implements the interface then the result is the
- * wrapped object or a proxy for the wrapped object. Otherwise return the
- * the result of calling <code>unwrap</code> recursively on the wrapped object
- * or a proxy for that result. If the receiver is not a
- * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
+ * If the receiver implements the interface then the result is the receiver or a
+ * proxy for the receiver. If the receiver is a wrapper and the wrapped object
+ * implements the interface then the result is the wrapped object or a proxy for
+ * the wrapped object. Otherwise return the the result of calling
+ * <code>unwrap</code> recursively on the wrapped object or a proxy for that
+ * result. If the receiver is not a wrapper and does not implement the
+ * interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
- * @return an object that implements the interface. May be a proxy for the actual implementing object.
- * @throws java.sql.SQLException If no object found that implements the interface
+ * @return an object that implements the interface. May be a proxy for the
+ * actual implementing object.
+ * @throws java.sql.SQLException If no object found that implements the
+ * interface
* @since 1.6
*/
+ @Override
public <T> T unwrap(Class<T> iface) throws SQLException {
T result;
if (iface.isInstance(this)) {
@@ -126,88 +136,96 @@
}
/**
- * Returns true if this either implements the interface argument or is directly or indirectly a wrapper
- * for an object that does. Returns false otherwise. If this implements the interface then return true,
- * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
- * object. If this does not implement the interface and is not a wrapper, return false.
- * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
- * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
- * returns true then calling <code>unwrap</code> with the same argument should succeed.
+ * Returns true if this either implements the interface argument or is directly
+ * or indirectly a wrapper for an object that does. Returns false otherwise. If
+ * this implements the interface then return true, else if this is a wrapper
+ * then return the result of recursively calling <code>isWrapperFor</code> on
+ * the wrapped object. If this does not implement the interface and is not a
+ * wrapper, return false. This method should be implemented as a low-cost
+ * operation compared to <code>unwrap</code> so that callers can use this method
+ * to avoid expensive <code>unwrap</code> calls that may fail. If this method
+ * returns true then calling <code>unwrap</code> with the same argument should
+ * succeed.
*
* @param iface a Class defining an interface.
- * @return true if this implements the interface or directly or indirectly wraps an object that does.
- * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
- * for an object with the given interface.
+ * @return true if this implements the interface or directly or indirectly wraps
+ * an object that does.
+ * @throws java.sql.SQLException if an error occurs while determining whether
+ * this is a wrapper for an object with the given interface.
* @since 1.6
*/
+ @Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
-
- boolean result;
if (iface.isInstance(this)) {
- result = true;
- } else {
- result = jdbcStatement.isWrapperFor(iface);
+ return true;
}
- return result;
+
+ return jdbcStatement.isWrapperFor(iface);
}
/**
* Retrieves any auto-generated keys created as a result of executing this
- * <code>Statement</code> object. If this <code>Statement</code> object did
- * not generate any keys, an empty <code>ResultSet</code>
- * object is returned.
+ * <code>Statement</code> object. If this <code>Statement</code> object did not
+ * generate any keys, an empty <code>ResultSet</code> object is returned.
* <p/>
- * <p><B>Note:</B>If the columns which represent the auto-generated keys were not specified,
- * the JDBC driver implementation will determine the columns which best represent the auto-generated keys.
+ * <p>
+ * <B>Note:</B>If the columns which represent the auto-generated keys were not
+ * specified, the JDBC driver implementation will determine the columns which
+ * best represent the auto-generated keys.
*
* @return a <code>ResultSet</code> object containing the auto-generated key(s)
- * generated by the execution of this <code>Statement</code> object
- * @throws SQLException if a database access error occurs or
- * this method is called on a closed <code>Statement</code>
- * @throws java.sql.SQLFeatureNotSupportedException
- * if the JDBC driver does not support this method
+ * generated by the execution of this <code>Statement</code> object
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed <code>Statement</code>
+ * @throws java.sql.SQLFeatureNotSupportedException if the JDBC driver does not
+ * support this method
* @since 1.4
*/
- public java.sql.ResultSet getGeneratedKeys() throws java.sql.SQLException {
- ResultSet rs = jdbcStatement.getGeneratedKeys();
- if (rs == null)
+ @Override
+ public ResultSet getGeneratedKeys() throws SQLException {
+ ResultSet resultSet = jdbcStatement.getGeneratedKeys();
+ if (resultSet == null) {
return null;
- return new ResultSetWrapper40(this, rs);
+ }
+
+ return new ResultSetWrapper40(this, resultSet);
}
/**
- * Retrieves the current result as a <code>ResultSet</code> object.
- * This method should be called only once per result.
+ * Retrieves the current result as a <code>ResultSet</code> object. This method
+ * should be called only once per result.
*
* @return the current result as a <code>ResultSet</code> object or
- * <code>null</code> if the result is an update count or there are no more results
- * @throws SQLException if a database access error occurs or
- * this method is called on a closed <code>Statement</code>
+ * <code>null</code> if the result is an update count or there are no more
+ * results
+ * @throws SQLException if a database access error occurs or this method is
+ * called on a closed <code>Statement</code>
* @see #execute
*/
- public java.sql.ResultSet getResultSet() throws java.sql.SQLException {
- ResultSet rs = jdbcStatement.getResultSet();
- if (rs == null)
+ @Override
+ public ResultSet getResultSet() throws SQLException {
+ ResultSet resultSet = jdbcStatement.getResultSet();
+ if (resultSet == null) {
return null;
- return new ResultSetWrapper40(this, rs);
+ }
+
+ return new ResultSetWrapper40(this, resultSet);
}
/**
* Executes the given SQL statement, which returns a single
* <code>ResultSet</code> object.
*
- * @param sql an SQL statement to be sent to the database, typically a
- * static SQL <code>SELECT</code> statement
- * @return a <code>ResultSet</code> object that contains the data produced
- * by the given query; never <code>null</code>
- * @throws SQLException if a database access error occurs,
- * this method is called on a closed <code>Statement</code> or the given
- * SQL statement produces anything other than a single
- * <code>ResultSet</code> object
+ * @param sql an SQL statement to be sent to the database, typically a static
+ * SQL <code>SELECT</code> statement
+ * @return a <code>ResultSet</code> object that contains the data produced by
+ * the given query; never <code>null</code>
+ * @throws SQLException if a database access error occurs, this method is called
+ * on a closed <code>Statement</code> or the given SQL statement produces
+ * anything other than a single <code>ResultSet</code> object
*/
- public java.sql.ResultSet executeQuery(final String sql) throws
- java.sql.SQLException {
- ResultSet rs = jdbcStatement.executeQuery(sql);
- return new ResultSetWrapper40(this, rs);
+ @Override
+ public ResultSet executeQuery(final String sql) throws SQLException {
+ return new ResultSetWrapper40(this, jdbcStatement.executeQuery(sql));
}
}
