| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| |
| package org.trafodion.jdbc.t4; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.lang.ref.Reference; |
| import java.lang.ref.ReferenceQueue; |
| import java.lang.ref.WeakReference; |
| import java.sql.Array; |
| import java.sql.Blob; |
| import java.sql.CallableStatement; |
| import java.sql.Clob; |
| import java.sql.DatabaseMetaData; |
| import java.sql.NClob; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLClientInfoException; |
| import java.sql.SQLException; |
| import java.sql.SQLXML; |
| import java.sql.Savepoint; |
| import java.sql.Statement; |
| import java.sql.Struct; |
| import java.util.ArrayList; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.concurrent.Executor; |
| import java.util.logging.FileHandler; |
| import java.util.logging.Level; |
| import java.util.logging.LogRecord; |
| import java.util.logging.Logger; |
| import java.util.HashMap; |
| import javax.sql.PooledConnection; |
| |
| /** |
| * <p> |
| * JDBC Type 4 TrafT4Connection class. |
| * </p> |
| * <p> |
| * Description: The <code>TrafT4Connection</code> class is an implementation of |
| * the <code>java.sql.Connection</code> interface. |
| * </p> |
| * |
| */ |
| public class TrafT4Connection extends PreparedStatementManager implements java.sql.Connection { |
| |
| private T4DatabaseMetaData metaData_; |
| /** |
| * Validates the connection by clearing warnings and verifying that the |
| * Connection is still open. |
| * |
| * @throws SQLException |
| * If the Connection is not valid |
| */ |
| private void validateConnection() throws SQLException { |
| clearWarnings(); |
| |
| if (this.ic_ == null || this.ic_.isClosed()) { |
| throw TrafT4Messages.createSQLException(this.props_, this.getLocale(), "invalid_connection", null); |
| } |
| } |
| |
| public String getRemoteProcess() throws SQLException { |
| return this.ic_.getRemoteProcess(); |
| } |
| |
| synchronized public void close() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "close", "", p); |
| } |
| |
| if (this.ic_ == null || this.ic_.isClosed()) |
| return; |
| |
| // only hard-close if no pooled connection exists |
| close((pc_ == null), true); |
| } |
| |
| public void commit() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "commit", "", p); |
| } |
| |
| validateConnection(); |
| |
| try { |
| ic_.commit(); |
| } catch (SQLException se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| public void resetServerIdleTimer() throws SQLException { |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| this.setConnectionAttr(InterfaceConnection.RESET_IDLE_TIMER, 0, "0"); |
| } |
| |
| public String getApplicationName() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getApplicationName(); |
| } |
| |
| public String getServerDataSource() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getServerDataSource(); |
| } |
| |
| public boolean getEnforceISO() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getEnforceISO(); |
| } |
| |
| public int getISOMapping() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getISOMapping(); |
| } |
| |
| public String getRoleName() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getRoleName(); |
| } |
| |
| public int getTerminalCharset() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getTerminalCharset(); |
| } |
| |
| public T4Properties getT4Properties() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.t4props_; |
| } |
| |
| public String getSessionName() throws SQLException { |
| validateConnection(); |
| |
| return this.ic_.getSessionName(); |
| } |
| |
| public Statement createStatement() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "createStatement", "", p); |
| } |
| |
| validateConnection(); |
| |
| try { |
| return new TrafT4Statement(this); |
| } catch (SQLException se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, resultSetType, resultSetConcurrency); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "createStatement", "", p); |
| } |
| |
| validateConnection(); |
| |
| try { |
| return new TrafT4Statement(this, resultSetType, resultSetConcurrency); |
| } catch (SQLException se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) |
| throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, resultSetType, resultSetConcurrency, |
| resultSetHoldability); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "createStatement", "", p); |
| } |
| |
| validateConnection(); |
| |
| try { |
| return new TrafT4Statement(this, resultSetType, resultSetConcurrency, resultSetHoldability); |
| } catch (SQLException se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| Locale getLocale() { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "getLocale", "", p); |
| } |
| if (ic_ != null) { |
| return ic_.getLocale(); |
| } else { |
| return null; |
| } |
| } |
| |
| public boolean getAutoCommit() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getAutoCommit", "getAutoCommit", p); |
| } |
| |
| validateConnection(); |
| |
| return ic_.getAutoCommit(); |
| } |
| |
| public String getCatalog() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getCatalog", "", p); |
| } |
| |
| validateConnection(); |
| |
| return ic_.getCatalog(); |
| } |
| |
| public String getSchema() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getSchema", "", p); |
| } |
| |
| validateConnection(); |
| |
| return ic_.getSchema(); |
| } |
| |
| public int getHoldability() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getHoldability", "", p); |
| } |
| |
| validateConnection(); |
| |
| return holdability_; |
| } |
| |
| public DatabaseMetaData getMetaData() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getMetaData", "getMetaData", p); |
| } |
| |
| validateConnection(); |
| |
| return this.metaData_; |
| } |
| |
| public int getTransactionIsolation() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getTransactionIsolation", "", p); |
| } |
| |
| validateConnection(); |
| |
| return ic_.getTransactionIsolation(); |
| } |
| |
| public Map getTypeMap() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getTypeMap", "", p); |
| } |
| |
| validateConnection(); |
| |
| return userMap_; |
| } |
| |
| void isConnectionOpen() throws SQLException { |
| validateConnection(); |
| } |
| |
| public boolean isClosed() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "isClosed", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("isClosed"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| boolean rv = true; |
| |
| if (ic_ == null) { |
| rv = true; |
| // return true; |
| } else { |
| clearWarnings(); |
| rv = ic_.getIsClosed(); |
| } |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "isClosed", "At exit return = " + rv, p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("isClosed"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| return rv; |
| // return ic_.get_isClosed(); |
| } |
| |
| // New method that checks if the connection is closed |
| // However, this is to be used only be internal classes |
| // It does not clear any warnings associated with the current connection |
| // Done for CASE 10_060123_4011 ; Swastik Bihani |
| boolean _isClosed() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "_isClosed", "", p); |
| } |
| if ( props_ != null && props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("_isClosed"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| boolean rv = true; |
| |
| if (ic_ == null) { |
| rv = true; |
| } else { |
| rv = ic_.getIsClosed(); |
| } |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "_isClosed", "At exit return = " + rv, p); |
| } |
| if ( props_ != null && props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("_isClosed"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| return rv; |
| } |
| |
| /** |
| * @deprecated |
| */ |
| public String getServiceName() throws SQLException { |
| return ""; |
| } |
| |
| /** |
| * @deprecated |
| */ |
| public void setServiceName(String serviceName) throws SQLException { |
| |
| } |
| |
| public boolean isReadOnly() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "isReadOnly", "", p); |
| } |
| |
| validateConnection(); |
| |
| return ic_.isReadOnly(); |
| } |
| |
| public String nativeSQL(String sql) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "nativeSQL", "", p); |
| } |
| |
| validateConnection(); |
| |
| return sql; |
| } |
| |
| public CallableStatement prepareCall(String sql) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareCall", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareCall"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| TrafT4CallableStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4CallableStatement) getPreparedStatement(this, sql, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, holdability_); |
| |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4CallableStatement(this, sql); |
| stmt.prepareCall(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, |
| holdability_); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| public CallableStatement prepareCall(String sql, String stmtLabel) throws SQLException { |
| final String QUOTE = "\""; |
| |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareCall", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareCall"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| if (stmtLabel == null || stmtLabel.length() == 0) { |
| throw TrafT4Messages.createSQLException(props_, null, "null_data", null); |
| } |
| |
| if (stmtLabel.startsWith(QUOTE) && stmtLabel.endsWith(QUOTE)) { |
| int len = stmtLabel.length(); |
| if (len == 2) { |
| throw TrafT4Messages.createSQLException(props_, null, "null_data", null); |
| } else { |
| stmtLabel = stmtLabel.substring(1, len - 1); |
| } |
| } else { |
| stmtLabel = stmtLabel.toUpperCase(); |
| } |
| |
| TrafT4CallableStatement stmt = null; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4CallableStatement) getPreparedStatement(this, sql, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, holdability_); |
| |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| if (stmtLabel.equalsIgnoreCase("null")) { |
| stmt = new TrafT4CallableStatement(this, sql); |
| } else { |
| stmt = new TrafT4CallableStatement(this, sql, stmtLabel); |
| } |
| stmt.prepareCall(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, |
| holdability_); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetConcurrency); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepaseCall", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetConcurrency); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepaseCall"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| TrafT4CallableStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4CallableStatement) getPreparedStatement(this, sql, resultSetType, resultSetConcurrency, |
| holdability_); |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4CallableStatement(this, sql, resultSetType, resultSetConcurrency); |
| stmt.prepareCall(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, resultSetType, resultSetConcurrency, holdability_); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, |
| int resultSetHoldability) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetConcurrency, |
| resultSetHoldability); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareCall", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetHoldability); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareCall"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| TrafT4CallableStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4CallableStatement) getPreparedStatement(this, sql, resultSetType, resultSetConcurrency, |
| resultSetHoldability); |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4CallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability); |
| |
| stmt.prepareCall(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, resultSetType, resultSetConcurrency, resultSetHoldability); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| /** |
| * Creates a <code>PreparedStatement</code> object for sending |
| * parameterized SQL statements to the database. |
| * |
| * @param sql |
| * SQL statement that might contain one or more '?' IN parameter |
| * placeholders |
| * @param stmtLabel |
| * SQL statement label that can be passed to the method instead |
| * of generated by the database system. |
| * @returns a new default PreparedStatement object containing the |
| * pre-compiled SQL statement |
| * @throws SQLException |
| * if a database access error occurs |
| */ |
| public PreparedStatement prepareStatement(String sql, String stmtLabel) throws SQLException { |
| final String QUOTE = "\""; |
| |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| if (stmtLabel == null || stmtLabel.length() == 0) { |
| throw TrafT4Messages.createSQLException(props_, null, "null_data", null); |
| } |
| |
| if (stmtLabel.startsWith(QUOTE) && stmtLabel.endsWith(QUOTE)) { |
| int len = stmtLabel.length(); |
| if (len == 2) { |
| throw TrafT4Messages.createSQLException(props_, null, "null_data", null); |
| } else { |
| stmtLabel = stmtLabel.substring(1, len - 1); |
| } |
| } else { |
| stmtLabel = stmtLabel.toUpperCase(); |
| } |
| |
| TrafT4PreparedStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4PreparedStatement) getPreparedStatement(this, sql, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, holdability_); |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4PreparedStatement(this, sql, stmtLabel); |
| |
| stmt.prepare(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, |
| holdability_); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| public PreparedStatement prepareStatement(String sql) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| TrafT4PreparedStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4PreparedStatement) getPreparedStatement(this, sql, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, holdability_); |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4PreparedStatement(this, sql); |
| |
| stmt.prepare(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, |
| holdability_); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| // SB 12/02/2004 - only for LOB statements - these will be not added to the |
| // statement cache |
| PreparedStatement prepareLobStatement(String sql) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareLobStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareLobStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| TrafT4PreparedStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| try { |
| stmt = new TrafT4PreparedStatement(this, sql); |
| stmt.prepare(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| |
| } |
| |
| public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, autoGeneratedKeys); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, autoGeneratedKeys); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| if (autoGeneratedKeys == TrafT4Statement.NO_GENERATED_KEYS) { |
| return prepareStatement(sql); |
| } else { |
| throw TrafT4Messages.createSQLException(props_, getLocale(), "auto_generated_keys_not_supported", null); |
| } |
| } |
| |
| public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, columnIndexes); |
| props_.t4Logger_.logp(Level.FINE, "SQLConnection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, columnIndexes); |
| lr.setParameters(p); |
| lr.setSourceClassName("SQLConnection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| if (columnIndexes != null && columnIndexes.length > 0) { |
| throw TrafT4Messages.createSQLException(props_, getLocale(), "auto_generated_keys_not_supported", null); |
| } else { |
| return prepareStatement(sql); |
| } |
| } |
| |
| public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) |
| throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetConcurrency); |
| props_.t4Logger_.logp(Level.FINE, "SQLConnection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetConcurrency); |
| lr.setParameters(p); |
| lr.setSourceClassName("SQLConnection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| TrafT4PreparedStatement stmt; |
| |
| clearWarnings(); |
| |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4PreparedStatement) getPreparedStatement(this, sql, resultSetType, resultSetConcurrency, |
| holdability_); |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4PreparedStatement(this, sql, resultSetType, resultSetConcurrency); |
| stmt.prepare(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, resultSetType, resultSetConcurrency, holdability_); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, |
| int resultSetHoldability) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetConcurrency, |
| resultSetHoldability); |
| props_.t4Logger_.logp(Level.FINE, "SQLConnection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, resultSetType, resultSetHoldability); |
| lr.setParameters(p); |
| lr.setSourceClassName("SQLConnection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| TrafT4PreparedStatement stmt; |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| try { |
| if (isStatementCachingEnabled()) { |
| stmt = (TrafT4PreparedStatement) getPreparedStatement(this, sql, resultSetType, resultSetConcurrency, |
| resultSetHoldability); |
| if (stmt != null) { |
| return stmt; |
| } |
| } |
| |
| stmt = new TrafT4PreparedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability); |
| stmt.prepare(stmt.sql_, stmt.queryTimeout_, stmt.resultSetHoldability_); |
| |
| if (isStatementCachingEnabled()) { |
| addPreparedStatement(this, sql, stmt, resultSetType, resultSetConcurrency, resultSetHoldability); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| return stmt; |
| } |
| |
| public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, columnNames); |
| props_.t4Logger_.logp(Level.FINE, "SQLConnection", "prepareStatement", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, sql, columnNames); |
| lr.setParameters(p); |
| lr.setSourceClassName("SQLConnection"); |
| lr.setSourceMethodName("prepareStatement"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| if (columnNames != null && columnNames.length > 0) { |
| throw TrafT4Messages.createSQLException(props_, getLocale(), "auto_generated_keys_not_supported", null); |
| } else { |
| return prepareStatement(sql); |
| } |
| } |
| |
| public void releaseSavepoint(Savepoint savepoint) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, savepoint); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "releaseSavepoint", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, savepoint); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("releaseSavepoint"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| TrafT4Messages.throwUnsupportedFeatureException(props_, getLocale(), "releaseSavepoint()"); |
| } |
| |
| public void rollback() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "rollback", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("rollback"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| // if (ic_.getTxid() == 0) - XA |
| // return; |
| |
| // commit the Transaction |
| try { |
| ic_.rollback(); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| // ic_.setTxid(0); - XA |
| } |
| |
| public void rollback(Savepoint savepoint) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, savepoint); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "rollback", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, savepoint); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("rollback"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| TrafT4Messages.throwUnsupportedFeatureException(props_, getLocale(), "rollback(Savepoint)"); |
| } |
| |
| public void setAutoCommit(boolean autoCommit) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, autoCommit); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setAutoCommit", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, autoCommit); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setAutoCommit"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| ic_.setAutoCommit(this, autoCommit); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| public void setCatalog(String catalog) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, catalog); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setCalalog", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, catalog); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setCalalog"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| if (catalog != null) { |
| try { |
| ic_.setCatalog(this, catalog); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| } |
| |
| public void setHoldability(int holdability) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, holdability); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setHoldability", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, holdability); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setHoldability"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| if (holdability != TrafT4ResultSet.CLOSE_CURSORS_AT_COMMIT) |
| |
| { |
| throw TrafT4Messages.createSQLException(props_, getLocale(), "invalid_holdability", null); |
| } |
| holdability_ = holdability; |
| } |
| |
| public void setReadOnly(boolean readOnly) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, readOnly); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setReadOnly", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, readOnly); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setReadOnly"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| // ic_.setReadOnly(readOnly); |
| ic_.setReadOnly(this, readOnly); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| public void setConnectionAttr(short attr, int valueNum, String valueString) throws SQLException { |
| ic_.setConnectionAttr(this, attr, valueNum, valueString); |
| } |
| |
| //3196 - NDCS transaction for SPJ |
| public void joinUDRTransaction(long transId) throws SQLException { |
| String sTransid = String.valueOf(transId); |
| ic_.setConnectionAttr(this, InterfaceConnection.SQL_ATTR_JOIN_UDR_TRANSACTION, 0, sTransid); |
| } |
| |
| //3196 - NDCS transaction for SPJ |
| public void suspendUDRTransaction() throws SQLException { |
| String sTransid = String.valueOf(ic_.transId_); |
| ic_.setConnectionAttr(this, InterfaceConnection.SQL_ATTR_SUSPEND_UDR_TRANSACTION, 0, sTransid); |
| } |
| |
| public Savepoint setSavepoint(String name) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, name); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setSavepoint", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, name); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setSavepoint"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| TrafT4Messages.throwUnsupportedFeatureException(props_, getLocale(), "setSavepoint"); |
| return null; |
| } |
| |
| public Savepoint setSavepoint() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setSavepoint", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setSavepoint"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| TrafT4Messages.throwUnsupportedFeatureException(props_, getLocale(), "setSavepoint"); |
| return null; |
| } |
| |
| public void setTransactionIsolation(int level) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, level); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setTransactionIsolation", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, level); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setTransactionIsolation"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| ic_.setTransactionIsolation(this, level); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| // JDK 1.2 |
| public void setTypeMap(java.util.Map map) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, map); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setTypeMap", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, map); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setTypeMap"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| userMap_ = map; |
| } |
| |
| public void begintransaction() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "begintransaction", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("begintransaction"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| try { |
| ic_.beginTransaction(); |
| |
| if (ic_.beginTransaction() == 0) { |
| return; |
| } else { |
| setAutoCommit(false); |
| } |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| |
| public long getCurrentTransaction() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getTxid", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("getTxid"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| return ic_.getTxid(); |
| } |
| |
| public void setTxid(long txid) throws SQLException { |
| setTransactionToJoin(Bytes.createLongBytes(txid, this.ic_.getByteSwap())); |
| } |
| |
| public void setTransactionToJoin(byte[] txid) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, txid); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "setTxid", "", p); |
| } |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| |
| transactionToJoin = txid; |
| } |
| |
| void gcStmts() { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "gcStmt", "", p); |
| } |
| Reference pRef; |
| String stmtLabel; |
| |
| while ((pRef = refStmtQ_.poll()) != null) { |
| stmtLabel = (String) refToStmt_.get(pRef); |
| // All PreparedStatement objects are added to HashMap |
| // Only Statement objects that produces ResultSet are added to |
| // HashMap |
| // Hence stmtLabel could be null |
| if (stmtLabel != null) { |
| try { |
| TrafT4Statement stmt = new TrafT4Statement(this, stmtLabel); |
| stmt.close(); |
| stmt = null; |
| } catch (SQLException e) { |
| performConnectionErrorChecks(e); |
| } finally { |
| refToStmt_.remove(pRef); |
| } |
| } |
| } |
| } |
| |
| void removeElement(Reference pRef) { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, pRef); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "removeElement", "", p); |
| } |
| |
| refToStmt_.remove(pRef); |
| pRef.clear(); |
| } |
| |
| void addElement(Reference pRef, String stmtLabel) { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, stmtLabel); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "addElement", "", p); |
| } |
| refToStmt_.put(pRef, stmtLabel); |
| } |
| |
| private void physicalCloseStatements() { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "physicalCloseStatement", "", p); |
| } |
| // close all the statements |
| ArrayList stmts = new ArrayList(refToStmt_.values()); |
| int size = stmts.size(); |
| for (int i = 0; i < size; i++) { |
| try { |
| String stmtLabel = (String) stmts.get(i); |
| TrafT4Statement stmt = new TrafT4Statement(this, stmtLabel); |
| stmt.close(); |
| stmt = null; |
| } catch (SQLException se) { |
| // Ignore any exception and proceed to the next statement |
| } |
| } |
| refToStmt_.clear(); |
| |
| |
| } |
| |
| private void rollbackAndIgnoreError() { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "rollbackAndIgnoreError", "", p); |
| } |
| // Rollback the Transaction when autoCommit mode is OFF |
| try { |
| if (getAutoCommit() == false ) { |
| rollback(); |
| } |
| } catch (SQLException sqex) { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "rollbackAndIgnoreError", "warning: "+sqex.getMessage(), p); |
| } |
| } |
| } |
| |
| |
| synchronized void close(boolean hardClose, boolean sendEvents) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, hardClose, sendEvents); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "close", "", p); |
| } |
| clearWarnings(); |
| try { |
| if (!hardClose) { |
| if (this.ic_ != null && this.ic_.getIsClosed()) { |
| return; |
| } |
| if (isStatementCachingEnabled()) { |
| closePreparedStatementsAll(); |
| } else { |
| physicalCloseStatements(); |
| } |
| rollbackAndIgnoreError(); |
| |
| /* |
| * //inform the NCS server to disregard the T4 ConnectionTimeout |
| * value try{ if (ic_ != null) { |
| * ic_.disregardT4ConnectionTimeout(this); } }catch(SQLException |
| * e){ //ignore - new property from old MXCS ABD version (now |
| * known as NCS) //ignored for backward compatibility } |
| */ |
| |
| // Need to logicallcally close the statement |
| pc_.logicalClose(sendEvents); |
| if (ic_ != null) { |
| ic_.setIsClosed(true); |
| } |
| } else { |
| if (getServerHandle() == null) { |
| return; |
| } |
| |
| // close all the statements |
| physicalCloseStatements(); |
| |
| // Need to logicallcally close the statement |
| // Rollback the Transaction when autoCommit mode is OFF |
| rollbackAndIgnoreError(); |
| |
| if (isStatementCachingEnabled()) { |
| clearPreparedStatementsAll(); |
| } |
| |
| // Close the connection |
| try { |
| ic_.close(); |
| } finally { |
| if (ic_ != null) { |
| ic_.removeElement(this); |
| } |
| ic_ = null; |
| } |
| } |
| } catch (SQLException e) { |
| performConnectionErrorChecks(e); |
| throw e; |
| } finally { |
| // close the timer thread |
| if (ic_ != null && ic_.getT4Connection() != null) { |
| ic_.getT4Connection().closeTimers(); |
| } |
| } |
| } |
| |
| protected void finalize() { |
| if (ic_ != null && ic_.getT4Connection() != null) { |
| ic_.getT4Connection().closeTimers(); |
| } |
| } |
| |
| void reuse() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "resue", "", p); |
| } |
| ic_.reuse(); |
| /* |
| * try { ic_.enforceT4ConnectionTimeout(this); } catch (TrafT4Exception |
| * se) { //performConnectionErrorChecks(se); //throw se; //ignore - new |
| * property from old MXCS ABD version (now known as NCS) //ignored for |
| * backward compatibility } |
| */ |
| } |
| |
| |
| // Extension method for WLS, this method gives the pooledConnection object |
| // associated with the given connection object. |
| public PooledConnection getPooledConnection() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getPooledConnection", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("getPooledConnection"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| if (pc_ != null) { |
| return pc_; |
| } else { |
| throw TrafT4Messages.createSQLException(props_, getLocale(), "null_pooled_connection", null); |
| } |
| } |
| |
| TrafT4Connection(TrafT4DataSource ds, T4Properties t4props) throws SQLException { |
| super(t4props); |
| |
| t4props.setConnectionID(Integer.toString(this.hashCode())); |
| setupLogging(t4props); |
| |
| if (t4props.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, ds, t4props); |
| t4props.t4Logger_.logp(Level.FINE, "TrafT4Connection", "<init>", "", p); |
| } |
| if ( t4props.t4Logger_.isLoggable(Level.FINE) && t4props.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, ds, t4props); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("<init>"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| t4props.getLogWriter().println(temp); |
| } |
| ds_ = ds; |
| |
| |
| makeConnection(t4props); |
| holdability_ = TrafT4ResultSet.CLOSE_CURSORS_AT_COMMIT; |
| } |
| |
| TrafT4Connection(TrafT4PooledConnection poolConn, T4Properties t4props) throws SQLException { |
| super(t4props); |
| |
| t4props.setConnectionID(Integer.toString(this.hashCode())); |
| setupLogging(t4props); |
| |
| if (t4props.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, poolConn, t4props); |
| t4props.t4Logger_.logp(Level.FINE, "TrafT4Connection", "<init>", "", p); |
| } |
| if ( t4props.t4Logger_.isLoggable(Level.FINE) && t4props.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, poolConn, t4props); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("<init>"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| t4props.getLogWriter().println(temp); |
| } |
| |
| pc_ = poolConn; |
| |
| |
| makeConnection(t4props); |
| holdability_ = TrafT4ResultSet.CLOSE_CURSORS_AT_COMMIT; |
| } |
| |
| private void makeConnection(T4Properties t4props) throws SQLException { |
| if (t4props.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, t4props); |
| t4props.t4Logger_.logp(Level.FINER, "TrafT4Connection", "makeConnection", "", p); |
| } |
| |
| ArrayList<String> addresses = createAddressList(t4props); |
| SQLException eList = null; |
| boolean success = false; |
| |
| for(int i=0;i<addresses.size();i++) { |
| clearWarnings(); |
| t4props.setUrl(addresses.get(i)); |
| |
| try { |
| ic_ = new InterfaceConnection(this, t4props); |
| success = true; |
| break; |
| } catch (SQLException se) { |
| boolean connectionError = performConnectionErrorChecks(se); |
| if(addresses.size() == 1 || !connectionError) { |
| throw se; |
| } |
| if(eList == null) { |
| eList = se; |
| } |
| else { |
| eList.setNextException(se); |
| } |
| } |
| } |
| |
| if(!success) { |
| throw eList; |
| } |
| |
| if (ic_.sqlwarning_ != null) { |
| setSqlWarning(ic_.sqlwarning_); |
| } |
| |
| refStmtQ_ = new ReferenceQueue(); |
| refToStmt_ = new HashMap(); |
| pRef_ = new WeakReference(this, ic_.refQ_); |
| ic_.refTosrvrCtxHandle_.put(pRef_, ic_); |
| props_ = t4props; |
| |
| ic_.enableNARSupport(this, props_.getBatchRecovery()); |
| |
| if (props_.getSPJEnv()) { |
| ic_.enableProxySyntax(this); |
| } |
| this.metaData_ = new T4DatabaseMetaData(this); |
| } |
| |
| private ArrayList<String> createAddressList(T4Properties t4props) { |
| ArrayList<String> addresses = new ArrayList<String>(); //10 addresses by default |
| addresses.add(t4props.getUrl()); |
| String os = System.getProperty("os.name"); |
| String enable = System.getProperty("t4jdbc.redirectaddr"); |
| |
| if(enable != null && enable.equals("true") && os != null && os.equals("NONSTOP_KERNEL")) { // TODO get real name |
| String providedUrl = t4props.getUrl(); |
| String providedHost = providedUrl.substring(16).toLowerCase(); |
| String hostPrefix = null; |
| try { |
| hostPrefix = java.net.InetAddress.getLocalHost().getHostName().substring(0, 5).toLowerCase(); |
| }catch(Exception e) { |
| } |
| |
| if(hostPrefix != null && providedHost.startsWith(hostPrefix)) { |
| File f = new File("/E/" + hostPrefix + "01/usr/t4jdbc/jdbcaddr.txt"); |
| if(f.exists()) { |
| addresses.clear(); |
| |
| String urlSuffix = providedUrl.substring(providedUrl.indexOf("/:")); |
| |
| try { |
| BufferedReader in = new BufferedReader(new FileReader(f)); |
| String host; |
| while ((host = in.readLine()) != null) { |
| if(host.indexOf(':') == -1) { |
| host += ":18650"; |
| } |
| addresses.add(String.format("jdbc:t4jdbc://" + host + urlSuffix)); |
| } |
| in.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| } |
| |
| return addresses; |
| } |
| |
| |
| |
| // -------------------------------------------------------- |
| private void setupLogging(T4Properties t4props) { |
| |
| String ID = T4LoggingUtilities.getUniqueID(); |
| String name = T4LoggingUtilities.getUniqueLoggerName(ID); |
| |
| if (t4props.getT4LogLevel() == Level.OFF) { |
| if (dummyLogger_ == null) { |
| dummyLogger_ = Logger.getLogger(name); |
| } |
| t4props.t4Logger_ = dummyLogger_; |
| } else { |
| t4props.t4Logger_ = Logger.getLogger(name); |
| } |
| |
| // t4props.t4Logger_ = Logger.getLogger(name); |
| t4props.t4Logger_.setUseParentHandlers(false); |
| t4props.t4Logger_.setLevel(t4props.getT4LogLevel()); |
| |
| if (t4props.getT4LogLevel() != Level.OFF) { |
| FileHandler fh1 = t4props.getT4LogFileHandler(); |
| t4props.t4Logger_.addHandler(fh1); |
| } |
| } // end setupLogging |
| |
| // -------------------------------------------------------- |
| |
| // Interface Methods |
| InterfaceConnection getServerHandle() { |
| if (props_.t4Logger_.isLoggable(Level.FINER) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINER, "TrafT4Connection", "getServerHandle", "", p); |
| } |
| return ic_; |
| } |
| |
| // Interface Methods |
| public int getDialogueId() throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "getDialogueId", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("getDialogueId"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| return getServerHandle().getDialogueId(); |
| } |
| |
| /** |
| * Returns true if the data format needs to be converted. Used by the |
| * <CODE>TrafT4ResultSet</CODE> class. |
| * |
| * @return true if conversion is needed; otherwise, false. |
| */ |
| public boolean getDateConversion() throws SQLException { |
| validateConnection(); |
| |
| return ic_.getDateConversion(); |
| } |
| |
| int getServerMajorVersion() throws SQLException { |
| validateConnection(); |
| |
| return ic_.getServerMajorVersion(); |
| } |
| |
| int getServerMinorVersion() throws SQLException { |
| validateConnection(); |
| |
| return ic_.getServerMinorVersion(); |
| } |
| |
| |
| void closeErroredConnection(TrafT4Exception se) { |
| try { |
| if (!erroredConnection) { // don't issue close repeatedly |
| erroredConnection = true; |
| if (pc_ != null) { |
| pc_.sendConnectionErrorEvent(se); |
| } else { |
| // hardclose |
| close(true, true); |
| } |
| } |
| } catch (Exception e) { |
| // ignore |
| } |
| } |
| |
| |
| boolean erroredConnection = false; |
| |
| PreparedStatement[] LobPreparedStatements = new PreparedStatement[14]; |
| |
| // boolean reserveEmptyDataLocator_ = false; |
| // public static final int EMPTY_DATA_LOCATOR_UPDATE = 0; |
| |
| String clobTableName_; |
| String blobTableName_; |
| // String preparedClobTableName_; |
| // String preparedBlobTableName_; |
| |
| static final int CLOB_INS_LOB_DATA_STMT = 0; |
| static final int CLOB_GET_LOB_DATA_STMT = 1; |
| static final int CLOB_GET_LOB_LEN_STMT = 2; |
| static final int CLOB_DEL_LOB_DATA_STMT = 3; |
| static final int CLOB_TRUN_LOB_DATA_STMT = 4; |
| static final int CLOB_UPD_LOB_DATA_STMT = 5; |
| static final int CLOB_GET_STRT_DATA_LOC_STMT = 6; |
| static final int BLOB_INS_LOB_DATA_STMT = 7; |
| static final int BLOB_GET_LOB_DATA_STMT = 8; |
| static final int BLOB_GET_LOB_LEN_STMT = 9; |
| static final int BLOB_DEL_LOB_DATA_STMT = 10; |
| static final int BLOB_TRUN_LOB_DATA_STMT = 11; |
| static final int BLOB_UPD_LOB_DATA_STMT = 12; |
| static final int BLOB_GET_STRT_DATA_LOC_STMT = 13; |
| |
| static Logger dummyLogger_ = null; |
| |
| boolean[] bLobStatementPrepared = new boolean[14]; // initialized to false, |
| // one each for the |
| // BLOB/CLOB statements |
| // listed above |
| |
| // Fields |
| InterfaceConnection ic_; |
| |
| // Connection |
| Map userMap_; |
| ReferenceQueue refStmtQ_; |
| HashMap refToStmt_; |
| int holdability_; |
| TrafT4DataSource ds_; |
| TrafT4PooledConnection pc_; |
| T4Driver driver_; |
| WeakReference pRef_; |
| T4Properties props_; |
| |
| byte[] transactionToJoin; |
| |
| |
| public Object unwrap(Class iface) throws SQLException { |
| try { |
| return iface.cast(this); |
| } catch (ClassCastException cce) { |
| throw TrafT4Messages.createSQLException(props_, this.getLocale(), "unable_unwrap", iface.toString()); |
| } |
| } |
| |
| public boolean isWrapperFor(Class iface) throws SQLException { |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } else { |
| return iface.isInstance(this); |
| } |
| } |
| |
| public Clob createClob() throws SQLException { |
| return new TrafT4Clob(this, null, null); |
| } |
| |
| public Blob createBlob() throws SQLException { |
| return new TrafT4Blob(this, null, null); |
| } |
| |
| public NClob createNClob() throws SQLException { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| |
| public SQLXML createSQLXML() throws SQLException { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| |
| public boolean isValid(int timeout) throws SQLException { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| public void setClientInfo(String name, String value) throws SQLClientInfoException { |
| ic_.setClientInfo(name, value); |
| } |
| |
| public void setClientInfo(Properties properties) throws SQLClientInfoException { |
| ic_.setClientInfoProperties( properties); |
| } |
| |
| public String getClientInfo(String name) throws SQLException { |
| validateConnection(); |
| return ic_.getClientInfoProperties().getProperty(name); |
| } |
| |
| public Properties getClientInfo() throws SQLException { |
| validateConnection(); |
| return ic_.getClientInfoProperties(); |
| } |
| |
| public Array createArrayOf(String typeName, Object[] elements) |
| throws SQLException { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| |
| public Struct createStruct(String typeName, Object[] attributes) |
| throws SQLException { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| |
| public void setSchema(String schema) throws SQLException { |
| if (props_.t4Logger_.isLoggable(Level.FINE) == true) { |
| Object p[] = T4LoggingUtilities.makeParams(props_, schema); |
| props_.t4Logger_.logp(Level.FINE, "TrafT4Connection", "setSchema", "", p); |
| } |
| if ( props_.t4Logger_.isLoggable(Level.FINE) && props_.getLogWriter() != null ) { |
| LogRecord lr = new LogRecord(Level.FINE, ""); |
| Object p[] = T4LoggingUtilities.makeParams(props_, schema); |
| lr.setParameters(p); |
| lr.setSourceClassName("TrafT4Connection"); |
| lr.setSourceMethodName("setSchema"); |
| T4LogFormatter lf = new T4LogFormatter(); |
| String temp = lf.format(lr); |
| props_.getLogWriter().println(temp); |
| } |
| clearWarnings(); |
| if (_isClosed() == true) { |
| throw TrafT4Messages.createSQLException(props_, null, "invalid_connection", null); |
| } |
| if (schema != null) { |
| try { |
| ic_.setSchema(this, schema); |
| } catch (TrafT4Exception se) { |
| performConnectionErrorChecks(se); |
| throw se; |
| } |
| } |
| } |
| |
| public void abort(Executor executor) throws SQLException { |
| if (ic_.getT4Connection().getInputOutput() != null) { |
| ic_.getT4Connection().getInputOutput().CloseIO(null); |
| } |
| ic_.setIsClosed(true); |
| |
| } |
| |
| public void setNetworkTimeout(Executor executor, int milliseconds) |
| throws SQLException { |
| validateConnection(); |
| props_.setNetworkTimeout(milliseconds); |
| } |
| |
| |
| public int getNetworkTimeout() throws SQLException { |
| validateConnection(); |
| return props_.getNetworkTimeout(); |
| } |
| |
| /* |
| * JDK 1.6 functions public Clob createClob() throws SQLException { return |
| * null; } |
| * |
| * |
| * public Blob createBlob() throws SQLException { return null; } |
| * |
| * |
| * public NClob createNClob() throws SQLException { return null; } |
| * |
| * |
| * public SQLXML createSQLXML() throws SQLException { return null; } |
| * |
| * |
| * public boolean isValid(int _int) throws SQLException { return false; } |
| * |
| * |
| * public void setClientInfo(String string, String string1) throws |
| * SQLClientInfoException { } |
| * |
| * |
| * public void setClientInfo(Properties properties) throws |
| * SQLClientInfoException { } |
| * |
| * |
| * public String getClientInfo(String string) throws SQLException { return |
| * ""; } |
| * |
| * |
| * public Properties getClientInfo() throws SQLException { return null; } |
| * |
| * |
| * public Array createArrayOf(String string, Object[] objectArray) throws |
| * SQLException { return null; } |
| * |
| * |
| * public Struct createStruct(String string, Object[] objectArray) throws |
| * SQLException { return null; } |
| * |
| * |
| * public Object unwrap(Class _class) throws SQLException { return null; } |
| * |
| * |
| * public boolean isWrapperFor(Class _class) throws SQLException { return |
| * false; } |
| */ |
| } |