Google Git
Sign in
apache / trafodion / 6b6d8800fe141986ef73b3af480d32d775b3ada7 / . / core / conn / jdbc_type2 / src / main / java / org / apache / trafodion / jdbc / t2 / SQLMXConnection.java
blob: 22ceb77e7d9d2ae010e04805d3c1e88b286242cf [file] [log] [blame]
// @@@ 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 @@@
/* -*-java-*-
* Filename : SQLMXConnection.java
* Description :
*/
package org.apache.trafodion.jdbc.t2;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
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.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Locale; // JDK 1.2
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.Executor;
import javax.sql.PooledConnection;
public class SQLMXConnection extends PreparedStatementManager implements
java.sql.Connection {
private static final short TYPE_UNKNOWN = 0;
private static final short TYPE_SELECT = 0x0001;
private static final short TYPE_UPDATE = 0x0002;
private static final short TYPE_DELETE = 0x0004;
private static final short TYPE_INSERT = 0x0008;
private static final short TYPE_INSERT_PARAM = 0x0120; //Modified for CQDs filter from 0x0100 to 0x0120
private static final short TYPE_EXPLAIN = 0x0010;
private static final short TYPE_CREATE = 0x0020;
private static final short TYPE_GRANT = 0x0040;
private static final short TYPE_DROP = 0x0080;
private static final short TYPE_CALL = 0x0800;
static final short TYPE_CONTROL = 0x0900;
private static CallableStatement createExternalCallableStatement(
String className, String call) throws SQLException {
Class classX = null;
/*
* Check if the Class exists in the Class path.
*/
try {
classX = Class.forName(className);
} catch (ClassNotFoundException e) {
throw new SQLException("Specified Class not found: "
+ e.getLocalizedMessage());
}
/*
* Check if the Class implements the CallableStatement interface.
*/
boolean blnIsCallableStatement = false;
if (classX != null) {
Class[] interfaces = classX.getInterfaces();
for (int nfor = 0; nfor < interfaces.length; ++nfor) {
if (interfaces[nfor].getName().equals(
CallableStatement.class.getName())) {
blnIsCallableStatement = true;
break;
}
}
}
if (!blnIsCallableStatement) {
throw new SQLException(
"The Specified Class does not implement java.sql.CallableStatement interface.");
}
Constructor[] array = null;
if (classX != null) {
array = classX.getDeclaredConstructors();
}
if (array != null) {
boolean blnPublic = false;
for (int nfor = 0; nfor < array.length; ++nfor) {
if (array[nfor].getModifiers() == Modifier.PUBLIC) {
blnPublic = true;
Class[] params = array[nfor].getParameterTypes();
if (params != null) {
if (params.length == 1) {
if (params[0].getName().equals(
String.class.getName())) {
Object initVar[] = new Object[1];
initVar[0] = call;
Object o = null;
try {
o = array[nfor].newInstance(initVar);
} catch (IllegalArgumentException e) {
throw new SQLException(e.getMessage());
} catch (InstantiationException e) {
throw new SQLException(e.getMessage());
} catch (IllegalAccessException e) {
throw new SQLException(e.getMessage());
} catch (InvocationTargetException e) {
throw new SQLException(e.getMessage());
}
return (CallableStatement) o;
}
}
}
}
}
if (!blnPublic) {
throw new SQLException(
"No Public Constructors available in the Specified Class.");
}
} else {
throw new SQLException(
"No Constructors available in the Specified Class.");
}
throw new SQLException(
"No Constructor available accepting ONLY java.lang.String parameter in the Specified Class.");
}
// java.sql.Connection interface methods
public void close() throws SQLException {
if (this.getTracer() != null)
this.getTracer().println(getTraceId() + "close()");
if (JdbcDebugCfg.entryActive)
debug[methodId_close_V].methodEntry(JdbcDebug.debugLevelPooling);
try {
// if it is a pooledConnection, don't do hardClose (Close SQL/MX
// Resources)
if (pc_ != null)
close(false, true);
else
close(true, true);
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_close_V].methodExit();
}
}
/*
* RFE: Connection synchronization commit() is now synchronized
*/
public synchronized void commit() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "commit()");
if (JdbcDebugCfg.entryActive)
debug[methodId_commit].methodEntry();
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
if (autoCommit_)
throw Messages.createSQLException(locale_,
"invalid_commit_mode", null);
if (beginTransFlag_) {
/*
* Transaction was started using Connection.begintransaction()
* API, set the autoCommit_ flag to true.
*/
autoCommit_ = true;
beginTransFlag_ = false;
}
Statement cs = null;
try {
// commit the Transaction
cs = this.createStatement();
cs.execute("commit");
} catch (SQLException se) {
if (se.getErrorCode() != -8605)
throw se;
}finally {
setTxid_(0);
if(cs != null ) {
try {cs.close();} catch(Exception ce) {}
}
}
}finally {
if (JdbcDebugCfg.traceActive)
debug[methodId_commit].traceOut(JdbcDebug.debugLevelEntry,
"beginTransFlag_ = " + beginTransFlag_
+ "; autoCommit_ = " + autoCommit_
+ "; txid_ = " + getTxid());
if (JdbcDebugCfg.entryActive)
debug[methodId_commit].methodExit();
}
}
public Statement createStatement() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "createStatement()");
if (JdbcDebugCfg.entryActive)
debug[methodId_createStatement].methodEntry();
try {
SQLMXStatement stmt = null;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
stmt = new SQLMXStatement(this);
if (out_ != null)
out_.println(getTraceId() + "createStatement() returns Statement ["
+ stmt.getStmtLabel_() + "]");
if (out_ != null) {
return new TStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_createStatement].methodExit();
}
}
public Statement createStatement(int resultSetType, int resultSetConcurrency)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "createStatement(" + resultSetType + ","
+ resultSetConcurrency + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_createStatement_II].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_createStatement_II]
.methodParameters("resultSetType=" + resultSetType
+ ", resultSetConcurrency=" + resultSetConcurrency);
try {
SQLMXStatement stmt = null;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
stmt = new SQLMXStatement(this, resultSetType, resultSetConcurrency);
if (out_ != null)
out_.println(getTraceId() + "createStatement(" + resultSetType + ","
+ resultSetConcurrency + ") returns Statement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_createStatement_II].methodExit();
}
}
public Statement createStatement(int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "createStatement(" + resultSetType + ","
+ resultSetConcurrency + "," + resultSetHoldability + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_createStatement_III].methodEntry();
try {
SQLMXStatement stmt = null;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
stmt = new SQLMXStatement(this, resultSetType,
resultSetConcurrency, resultSetHoldability);
if (out_ != null)
out_.println(getTraceId() + "createStatement(" + resultSetType + ","
+ resultSetConcurrency + "," + resultSetHoldability
+ ") returns Statement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_createStatement_III].methodExit();
}
}
public boolean getAutoCommit() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getAutoCommit()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getAutoCommit].methodEntry();
try {
clearWarnings();
return autoCommit_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getAutoCommit].methodExit();
}
}
public String getCatalog() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getCatalog()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getCatalog].methodEntry();
try {
clearWarnings();
Statement s = null;
ResultSet rs = null;
String catalog = null;
try {
s = this.createStatement();
rs = s.executeQuery("SHOWCONTROL DEFAULT CATALOG, match full, no header");
rs.next();
catalog = rs.getString(1);
catalog = catalog.substring(catalog.indexOf('.') + 1);
} catch (SQLException e) {
return this.t2props.getCatalog();
} finally {
if (rs != null)
rs.close();
if (s != null)
s.close();
}
return catalog;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getCatalog].methodExit();
}
}
public int getHoldability() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getCatalog()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getHoldability].methodEntry();
try {
clearWarnings();
return holdability_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getHoldability].methodExit();
}
}
public DatabaseMetaData getMetaData() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getMetaData()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getMetaData].methodEntry();
try {
SQLMXDatabaseMetaData metaData;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
metaData = new SQLMXDatabaseMetaData(this);
if (out_ != null)
out_.println(getTraceId() + "getMetaData() returns DatabaseMetaData ["
+ System.identityHashCode(metaData) + "]");
if(out_ != null) {
return new TDatabaseMetaData(metaData, new TConnection(this, out_), out_);
}
return metaData;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getMetaData].methodExit();
}
}
public int getTransactionIsolation() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getTransactionIsolation()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getTransactionIsolation].methodEntry();
try {
clearWarnings();
return transactionIsolation_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getTransactionIsolation].methodExit();
}
}
// JDK 1.2
public java.util.Map<String, Class<?>> getTypeMap() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getTypeMap()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getTypeMap].methodEntry();
try {
clearWarnings();
return userMap_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getTypeMap].methodExit();
}
}
public boolean isClosed() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "isClosed()");
if (JdbcDebugCfg.entryActive)
debug[methodId_isClosed].methodEntry();
try {
clearWarnings();
return isClosed_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_isClosed].methodExit();
}
}
public boolean isReadOnly() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "isReadOnly()");
if (JdbcDebugCfg.entryActive)
debug[methodId_isReadOnly].methodEntry();
try {
clearWarnings();
return isReadOnly_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_isReadOnly].methodExit();
}
}
public String nativeSQL(String sql) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "nativeSQL(\"" + sql + "\")");
if (JdbcDebugCfg.entryActive)
debug[methodId_nativeSQL].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_nativeSQL].methodParameters("sql=" + sql);
try {
clearWarnings();
return sql;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_nativeSQL].methodExit();
}
}
/*
* RFE: Connection synchronization prepareCall() is now synchronized
*/
public synchronized CallableStatement prepareCall(String sql)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareCall(\"" + sql + "\")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareCall_L].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareCall_L].methodParameters("sql=" + sql);
try {
if (!this.t2props.getExternalCallHandler().equals("NONE")) {
String sqlX = sql;
// Set the prefix:
String prefix = "EXT";
String callHandler = "NONE";
if (!this.t2props.getExternalCallHandler().equals("NONE")) {
// callHandler = SQLMXDataSource.externalCallHandler;
callHandler = this.t2props.getExternalCallHandler();
}
if (!this.t2props.getExternalCallPrefix().equalsIgnoreCase("EXT")) {
prefix = this.t2props.getExternalCallPrefix();
}
if (sqlX.trim().startsWith("{")) {
sqlX = sqlX.trim().substring(1).trim();
if (sqlX.toUpperCase().startsWith(prefix.toUpperCase())) {
CallableStatement externalCallStmt = SQLMXConnection
.createExternalCallableStatement(callHandler,
sql);
return externalCallStmt;
}
}
}
SQLMXCallableStatement cstmt;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
gcStmts();
if (isStatementCachingEnabled()) {
cstmt = (SQLMXCallableStatement) getPreparedStatement(this,
sql.trim(), ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY, holdability_);
if (cstmt != null) {
if (out_ != null) {
out_.println(getTraceId() + "prepareCall(\"" + sql
+ "\") returns CallableStatement ["
+ cstmt.getStmtLabel_() + "]");
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency,resultSetHoldability) "
+ cstmt.stmtId_+"\"+ GOT STMT FROM CACHE ");
}
}
if(out_ != null) {
return new TCallableStatement(cstmt, out_);
}
return cstmt;
}
}
cstmt = new SQLMXCallableStatement(this, sql);
pStmtCount++;
if (out_ != null) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareCall(String) "
+ "PREPARED STMT - " + "\""
+ cstmt.stmtId_ + "\"");
out_.println(getTraceId() + "prepareCall(String) "
+ "\""+"PREPARED STMT COUNT:"+this.pStmtCount
+ "\"");
}
}
if (this.t2props.getEnableLog().equalsIgnoreCase("ON"))
printIdMapEntry(cstmt);
cstmt.prepareCall(server_, getDialogueId(), getTxid(),
autoCommit_, transactionMode_, cstmt.getStmtLabel_(),
cstmt.sql_.trim(), cstmt.queryTimeout_,
cstmt.resultSetHoldability_, cstmt.fetchSize_);
if (isStatementCachingEnabled()) {
addPreparedStatement(this, cstmt.sql_.trim(), cstmt,
ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY, holdability_);
}
addElement(cstmt);
if (out_ != null)
out_.println(getTraceId() + "prepareCall(\"" + sql
+ "\") returns CallableStatement ["
+ cstmt.getStmtLabel_() + "]");
if (out_ != null) {
return new TCallableStatement(cstmt, out_);
}
return cstmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareCall_L].methodExit();
}
}
/*
* RFE: Connection synchronization prepareCall() is now synchronized
*/
public synchronized CallableStatement prepareCall(String sql,
int resultSetType, int resultSetConcurrency) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareCall(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareCall_LII].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareCall_LII].methodParameters("sql=" + sql
+ ", resultSetType=" + resultSetType
+ ", resultSetConcurrency=" + resultSetConcurrency);
try {
SQLMXCallableStatement cstmt;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
gcStmts();
if (isStatementCachingEnabled()) {
cstmt = (SQLMXCallableStatement) getPreparedStatement(this,
sql.trim(), resultSetType, resultSetConcurrency, holdability_);
if (cstmt != null) {
if (out_ != null) {
out_.println(getTraceId() + "prepareCall(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency
+ ") returns CallableStatement ["
+ cstmt.getStmtLabel_() + "]");
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareCall(String,resultSetType,resultSetConcurrency) "
+ cstmt.stmtId_+"\" GOT STMT FROM CACHE ");
}
}
if(out_ != null) {
return new TCallableStatement(cstmt, out_);
}
return cstmt;
}
}
cstmt = new SQLMXCallableStatement(this, sql, resultSetType,
resultSetConcurrency);
pStmtCount++;
if (out_ != null) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareCall(String,resultSetType,resultSetConcurrency) "
+ " PREPARED STMT - " + "\""
+ cstmt.stmtId_ + "\"");
out_.println(getTraceId() + "prepareCall(String,resultSetType,resultSetConcurrency) "
+ "\""+"PREPARED STMT COUNT:"+this.pStmtCount
+ "\"");
}
}
if (this.t2props.getEnableLog().equalsIgnoreCase("ON"))
printIdMapEntry(cstmt);
cstmt.prepareCall(server_, getDialogueId(), getTxid(),
autoCommit_, transactionMode_, cstmt.getStmtLabel_(),
cstmt.sql_.trim(), cstmt.queryTimeout_,
cstmt.resultSetHoldability_, cstmt.fetchSize_);
if (isStatementCachingEnabled()) {
addPreparedStatement(this, cstmt.sql_.trim(), cstmt,
resultSetType, resultSetConcurrency, holdability_);
}
addElement(cstmt);
if (out_ != null)
out_.println(getTraceId() + "prepareCall(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency
+ ") returns CallableStatement ["
+ cstmt.getStmtLabel_() + "]");
if (out_ != null) {
return new TCallableStatement(cstmt, out_);
}
return cstmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareCall_LII].methodExit();
}
}
/*
* RFE: Connection synchronization prepareCall() is now synchronized
*/
public synchronized CallableStatement prepareCall(String sql,
int resultSetType, int resultSetConcurrency,
int resultSetHoldability) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareCall(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ","
+ resultSetHoldability + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareCall_LIII].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareCall_LIII].methodParameters("sql=" + sql
+ ", resultSetType=" + resultSetType
+ ", resultSetConcurrency=" + resultSetConcurrency
+ ", resultSetHoldability=" + resultSetHoldability);
try {
SQLMXCallableStatement cstmt;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
gcStmts();
if (isStatementCachingEnabled()) {
cstmt = (SQLMXCallableStatement) getPreparedStatement(this, sql
.trim(), resultSetType, resultSetConcurrency,
resultSetHoldability);
if (cstmt != null) {
if (out_ != null) {
out_.println(getTraceId() + "prepareCall(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ","
+ resultSetHoldability + ") returns CallableStatement ["
+ cstmt.getStmtLabel_() + "]");
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "repareCall(String,resultSetType,resultSetConcurrency,resultSetHoldability)"
+ cstmt.stmtId_+"\"+ GOT STMT FROM CACHE ");
}
}
if(out_ != null) {
return new TCallableStatement(cstmt, out_);
}
return cstmt;
}
}
cstmt = new SQLMXCallableStatement(this, sql, resultSetType,
resultSetConcurrency, resultSetHoldability);
pStmtCount++;
if (out_ != null) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareCall(String,resultSetType,resultSetConcurrency,resultSetHoldability) "
+ " PREPARED STMT - " + "\""
+ cstmt.stmtId_ + "\"");
out_.println(getTraceId() + "prepareCall(String,resultSetType,resultSetConcurrency,resultSetHoldability) "
+"\""+"PREPARED STMT COUNT:"+this.pStmtCount
+ "\"");
}
}
if (this.t2props.getEnableLog().equalsIgnoreCase("ON"))
printIdMapEntry(cstmt);
cstmt.prepareCall(server_, getDialogueId(), getTxid(),
autoCommit_, transactionMode_, cstmt.getStmtLabel_(),
cstmt.sql_.trim(), cstmt.queryTimeout_,
cstmt.resultSetHoldability_, cstmt.fetchSize_);
if (isStatementCachingEnabled()) {
addPreparedStatement(this, cstmt.sql_.trim(), cstmt,
resultSetType, resultSetConcurrency,
resultSetHoldability);
}
addElement(cstmt);
if (out_ != null)
out_.println(getTraceId() + "prepareCall(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ","
+ resultSetHoldability + ") returns CallableStatement ["
+ cstmt.getStmtLabel_() + "]");
if (out_ != null) {
return new TCallableStatement(cstmt, out_);
}
return cstmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareCall_LIII].methodExit();
}
}
/*
* RFE: Connection synchronization prepareStatement() is now synchronized
*/
public synchronized PreparedStatement prepareStatement(String sql)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_L].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareStatement_L].methodParameters("sql=" + sql);
try {
SQLMXPreparedStatement pstmt;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
gcStmts();
if (isStatementCachingEnabled()) {
pstmt = (SQLMXPreparedStatement) getPreparedStatement(this,
sql.trim(), ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY, holdability_);
if (pstmt != null) {
if (out_ != null) {
out_.println(getTraceId() + "prepareStatement(\"" + sql
+ "\") returns PreparedStatement ["
+ (pstmt).getStmtLabel_() + "]");
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String) "
+ pstmt.stmtId_+"\"+ GOT STMT FROM CACHE ");
}
}
if(out_ != null) {
return new TPreparedStatement(pstmt, out_);
}
return pstmt;
}
}
pstmt = new SQLMXPreparedStatement(this, sql);
pStmtCount++;
if (out_ != null) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String) "
+ " PREPARED STMT - " + "\""
+ pstmt.stmtId_ + "\"");
out_.println(getTraceId() + "prepareStatement(String) "
+"\""+"PREPARED STMT COUNT:"+this.pStmtCount
+ "\"");
}
}
if (this.t2props.getEnableLog().equalsIgnoreCase("ON"))
printIdMapEntry(pstmt);
// not insert
int batchBindingSizePrev = 0;
// if (SQLMXConnection.getSqlStmtType(sql) != SQLMXConnection.TYPE_INSERT
// && SQLMXConnection.getSqlStmtType(sql) != SQLMXConnection.TYPE_INSERT_PARAM) {
//
// batchBindingSizePrev = batchBindingSize_;
// batchBindingSize_ = 0;
// }
//
/* Selva
if ( pstmt.getSqlType() != SQLMXConnection.TYPE_INSERT
&& pstmt.getSqlType() != SQLMXConnection.TYPE_INSERT_PARAM
&& pstmt.getSqlType() != SQLMXConnection.TYPE_UPDATE
&& pstmt.getSqlType() != SQLMXConnection.TYPE_DELETE
)
{
batchBindingSizePrev = this.t2props.getBatchBinding();
batchBindingSize_ = 0;
}
*/
pstmt.prepare(server_, getDialogueId(), getTxid(), autoCommit_,
pstmt.getStmtLabel_(), pstmt.sql_.trim(), pstmt.isSelect_,
pstmt.queryTimeout_, pstmt.resultSetHoldability_,
batchBindingSize_, pstmt.fetchSize_);
// value
// if (SQLMXConnection.getSqlStmtType(sql) != SQLMXConnection.TYPE_INSERT
// && SQLMXConnection.getSqlStmtType(sql) != SQLMXConnection.TYPE_INSERT_PARAM) {
//
// batchBindingSize_ = batchBindingSizePrev;
// }
/*
if (pstmt.getSqlType() != SQLMXConnection.TYPE_INSERT
&& pstmt.getSqlType() != SQLMXConnection.TYPE_INSERT_PARAM
&& pstmt.getSqlType() != SQLMXConnection.TYPE_UPDATE
&& pstmt.getSqlType() != SQLMXConnection.TYPE_DELETE
)
{
batchBindingSize_ = batchBindingSizePrev;
}
// End
*/
if (isStatementCachingEnabled()) {
addPreparedStatement(this, pstmt.sql_.trim(), pstmt,
ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY, holdability_);
}
addElement(pstmt);
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql
+ "\") returns PreparedStatement ["
+ (pstmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TPreparedStatement(pstmt, out_);
}
return pstmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_L].methodExit();
}
}
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ autoGeneratedKeys + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LI].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareStatement_LI].methodParameters("sql=" + sql
+ ", autoGeneratedKeys=" + autoGeneratedKeys);
try {
if (autoGeneratedKeys != SQLMXStatement.NO_GENERATED_KEYS)
throw Messages.createSQLException(locale_,
"auto_generated_keys_not_supported", null);
SQLMXPreparedStatement stmt = (SQLMXPreparedStatement) prepareStatement(sql);
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ autoGeneratedKeys + ") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LI].methodExit();
}
}
public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ columnIndexes + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LI_array].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareStatement_LI_array]
.methodParameters("sql=" + sql + ", int["
+ columnIndexes.length + "] columnIndexes");
try {
if (columnIndexes != null && columnIndexes.length > 0)
throw Messages.createSQLException(locale_,
"auto_generated_keys_not_supported", null);
SQLMXPreparedStatement stmt = (SQLMXPreparedStatement) prepareStatement(sql);
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ columnIndexes + ") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LI_array].methodExit();
}
}
/*
* RFE: Connection synchronization prepareStatement() is now synchronized
*/
public synchronized PreparedStatement prepareStatement(String sql,
int resultSetType, int resultSetConcurrency) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LII].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareStatement_LII].methodParameters("sql=" + sql
+ ", resultSetType=" + resultSetType
+ ", resultSetConcurrency=" + resultSetConcurrency);
try {
SQLMXPreparedStatement stmt;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
gcStmts();
if (isStatementCachingEnabled()) {
stmt = (SQLMXPreparedStatement) getPreparedStatement(this, sql
.trim(), resultSetType, resultSetConcurrency,
holdability_);
if (stmt != null) {
if (out_ != null) {
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency
+ ") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency) "
+ stmt.stmtId_+"\"+ GOT STMT FROM CACHE ");
}
}
if(out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}
}
stmt = new SQLMXPreparedStatement(this, sql, resultSetType,
resultSetConcurrency);
pStmtCount++;
if (out_ != null) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency) "
+ " PREPARED STMT - " + "\""
+ stmt.stmtId_ + "\"");
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency) "
+"\""+"PREPARED STMT COUNT:"+this.pStmtCount
+ "\"");
}
}
if (this.t2props.getEnableLog().equalsIgnoreCase("ON"))
printIdMapEntry(stmt);
/*
// is not insert
int batchBindingSizePrev = 0;
if (stmt.getSqlType() != SQLMXConnection.TYPE_INSERT
&& stmt.getSqlType() != SQLMXConnection.TYPE_INSERT_PARAM) {
batchBindingSizePrev = this.t2props.getBatchBinding();
batchBindingSize_ = 0;
}
*/
stmt.prepare(server_, getDialogueId(), getTxid(),
autoCommit_, stmt.getStmtLabel_(), stmt.sql_.trim(),
stmt.isSelect_, stmt.queryTimeout_,
stmt.resultSetHoldability_, batchBindingSize_,
stmt.fetchSize_);
/*
if (stmt.getSqlType() != SQLMXConnection.TYPE_INSERT
&& stmt.getSqlType() != SQLMXConnection.TYPE_INSERT_PARAM) {
batchBindingSize_ = batchBindingSizePrev;
}
*/
if (isStatementCachingEnabled()) {
addPreparedStatement(this, stmt.sql_.trim(), stmt,
resultSetType, resultSetConcurrency, holdability_);
}
addElement(stmt);
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency
+ ") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LII].methodExit();
}
}
/*
* RFE: Connection synchronization prepareStatement() is now synchronized
*/
public synchronized PreparedStatement prepareStatement(String sql,
int resultSetType, int resultSetConcurrency,
int resultSetHoldability) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ","
+ resultSetHoldability + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LIII].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareStatement_LIII].methodParameters("sql=" + sql
+ ", resultSetType=" + resultSetType
+ ", resultSetConcurrency=" + resultSetConcurrency
+ ", resultSetHoldability=" + resultSetHoldability);
try {
SQLMXPreparedStatement stmt;
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
connectInit();
gcStmts();
if (isStatementCachingEnabled()) {
stmt = (SQLMXPreparedStatement) getPreparedStatement(this, sql
.trim(), resultSetType, resultSetConcurrency,
resultSetHoldability);
if (stmt != null) {
if (out_ != null) {
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ","
+ resultSetHoldability + ") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency,resultSetHoldability) "
+ stmt.stmtId_+"\"+ GOT STMT FROM CACHE ");
}
}
if(out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}
}
stmt = new SQLMXPreparedStatement(this, sql, resultSetType,
resultSetConcurrency, resultSetHoldability);
pStmtCount++;
if (out_ != null) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency,resultSetHoldability) "
+ " PREPARED STMT - " + "\""
+ stmt.stmtId_ + "\"");
out_.println(getTraceId() + "prepareStatement(String,resultSetType,resultSetConcurrency,resultSetHoldability) "
+"\""+"PREPARED STMT COUNT:"+this.pStmtCount
+ "\"");
}
}
if (this.t2props.getEnableLog().equalsIgnoreCase("ON"))
printIdMapEntry(stmt);
/*
batchBindingSizePrev = this.t2props.getBatchBinding();
// is not insert
int batchBindingSizePrev = 0;
if (stmt.getSqlType() != SQLMXConnection.TYPE_INSERT
&&stmt.getSqlType() != SQLMXConnection.TYPE_INSERT_PARAM) {
batchBindingSizePrev = this.t2props.getBatchBinding();
batchBindingSize_ = 0;
}
*/
stmt.prepare(server_, getDialogueId(), getTxid(),
autoCommit_, stmt.getStmtLabel_(), stmt.sql_.trim(),
stmt.isSelect_, stmt.queryTimeout_,
stmt.resultSetHoldability_, batchBindingSize_,
stmt.fetchSize_);
/*
if (stmt.getSqlType() != SQLMXConnection.TYPE_INSERT
&& stmt.getSqlType() != SQLMXConnection.TYPE_INSERT_PARAM) {
batchBindingSize_ = batchBindingSizePrev;
}
*/
if (isStatementCachingEnabled()) {
addPreparedStatement(this, stmt.sql_.trim(), stmt,
resultSetType, resultSetConcurrency,
resultSetHoldability);
}
addElement(stmt);
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\","
+ resultSetType + "," + resultSetConcurrency + ","
+ resultSetHoldability
+ ") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LIII].methodExit();
}
}
public PreparedStatement prepareStatement(String sql, String[] columnNames)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql + "\")");
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LL_array].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_prepareStatement_LL_array].methodParameters("sql="
+ sql + ", String[" + columnNames.length + "] columnNames");
try {
if (columnNames != null && columnNames.length > 0)
throw Messages.createSQLException(locale_,
"auto_generated_keys_not_supported", null);
SQLMXPreparedStatement stmt = (SQLMXPreparedStatement) prepareStatement(sql);
if (out_ != null)
out_.println(getTraceId() + "prepareStatement(\"" + sql
+ "\") returns PreparedStatement ["
+ ((SQLMXStatement) stmt).getStmtLabel_() + "]");
if (out_ != null) {
return new TPreparedStatement(stmt, out_);
}
return stmt;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_prepareStatement_LL_array].methodExit();
}
}
//**************************************************************************
// * Function: releaseSavepoint(Savepoint)
// *
// * Description: This is a required method for the JDBC 3.0 API. This
// method
// * takes a Savepoint object as a parameter and removes it from
// * current transaction.
// *
// * Input: Savepoint object, one that was previous saved.
// *
// * NOTE: This is an unsupported function, calling it will cause an
// * unsupported exception to be thown.
// *
//**************************************************************************
// *
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_releaseSavepoint].methodEntry();
try {
clearWarnings();
Messages.throwUnsupportedFeatureException(locale_,
"releaseSavepoint()");
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_releaseSavepoint].methodExit();
}
}
/*
* RFE: Connection synchronization rollback() is now synchronized.
*/
public synchronized void rollback() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "rollback()");
if (JdbcDebugCfg.entryActive)
debug[methodId_rollback_V].methodEntry();
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
if (autoCommit_)
throw Messages.createSQLException(locale_,
"invalid_commit_mode", null);
if (beginTransFlag_) {
/*
* Transaction was started using Connection.begintransaction()
* API, set the autoCommit_ flag to true.
*/
autoCommit_ = true;
beginTransFlag_ = false;
}
Statement cs = null;
try {
// commit the Transaction
cs = this.createStatement();
cs.execute("rollback");
} catch (SQLException se) {
if (se.getErrorCode() != -8609)
throw se;
}finally {
if(cs != null) {
try {cs.close();} catch(Exception ee) {}
}
setTxid_(0);
}
}finally {
if (JdbcDebugCfg.traceActive)
debug[methodId_rollback_V].traceOut(JdbcDebug.debugLevelEntry,
"beginTransFlag_ = " + beginTransFlag_
+ "; autoCommit_ = " + autoCommit_
+ "; txid_ = " + getTxid());
if (JdbcDebugCfg.entryActive)
debug[methodId_rollback_V].methodExit();
}
}
//**************************************************************************
// * Function: rollback(SavePoint)
// *
// * Description: This is a required method for the JDBC 3.0 API. This
// method
// * takes a Savepoint object as a parameter and roll back to when
// * that Savepoint object was taken.
// *
// * Input: Savepoint object, one that was previous saved.
// *
// * NOTE: This is an unsupported function, calling it will cause an
// * unsupported exception to be thown.
// *
//**************************************************************************
// *
public void rollback(Savepoint savepoint) throws SQLException {
if (out_ != null) {
out_.println(getTraceId() + "rollback (" + savepoint + ")");
}
if (JdbcDebugCfg.entryActive)
debug[methodId_rollback_L].methodEntry();
try {
clearWarnings();
Messages.throwUnsupportedFeatureException(locale_,
"rollback(Savepoint)");
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_rollback_L].methodExit();
}
}
public void setAutoCommit(boolean autoCommit) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "setAutoCommit(" + autoCommit + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_setAutoCommit].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_setAutoCommit].methodParameters("autoCommit="
+ autoCommit);
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_, "invalid_connection", null);
if(this.getAutoCommit() == autoCommit) {
return;
}
//changes to comply with standards, if autocommit mode is same then NO-OP
// Don't allow autoCommit false when internal txn mode
if (transactionMode_ == TXN_MODE_INTERNAL)
autoCommit_ = true;
else
{
if (autoCommit_ != autoCommit)
{
if (connectInitialized_)
setAutoCommit(server_, getDialogueId(), autoCommit);
autoCommit_ = autoCommit;
}
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setAutoCommit].methodExit();
}
}
/*
* RFE: Connection synchronization setCatalog() is now synchronized.
*/
public synchronized void setCatalog(String catalog) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "setCatalog(\"" + catalog + "\")");
if (JdbcDebugCfg.entryActive)
debug[methodId_setCatalog].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_setCatalog].methodParameters("catalog=" + catalog);
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
if (catalog != null) {
setCatalog(server_, getDialogueId(), catalog);
if (!catalog.startsWith("\""))
catalog_ = catalog.toUpperCase();
else
catalog_ = catalog;
updateConnectionReusability(SQL_SET_CATALOG);
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setCatalog].methodExit();
}
}
public void setHoldability(int holdability) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "setHoldability(\"" + holdability + "\")");
if (JdbcDebugCfg.entryActive)
debug[methodId_setHoldability].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_setHoldability].methodParameters("holdability="
+ holdability);
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
if (holdability != SQLMXResultSet.HOLD_CURSORS_OVER_COMMIT
&& holdability != SQLMXResultSet.CLOSE_CURSORS_AT_COMMIT)
throw Messages.createSQLException(locale_,
"invalid_holdability", null);
holdability_ = holdability;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setHoldability].methodExit();
}
}
public void setReadOnly(boolean readOnly) throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "setReadOnly(" + readOnly + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_setReadOnly].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_setReadOnly]
.methodParameters("readOnly=" + readOnly);
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
// setReadOnly(server_, dialogueId_, readOnly);
isReadOnly_ = readOnly;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setReadOnly].methodExit();
}
}
//**************************************************************************
// * Function: setSavepoint(String)
// *
// * Description: This is a required method for the JDBC 3.0 API. This
// method
// * takes a String object as a parameter and returns a Savepoint
// * object.
// *
// * Input: String Object - Optional name of the setpoint.
// * Returns: Setpoint Object - used to roll back to this point in time.
// *
// * NOTE: This is an unsupported function, calling it will cause an
// * unsupported exception to be thown.
// *
//**************************************************************************
// *
public Savepoint setSavepoint(String name) throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_setSavepoint_L].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_setSavepoint_L].methodParameters("name=" + name);
try {
clearWarnings();
Messages.throwUnsupportedFeatureException(locale_, "setSavepoint");
return null;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setSavepoint_L].methodExit();
}
}
//**************************************************************************
// * Function: setSavepoint()
// *
// * Description: This is a required method for the JDBC 3.0 API. This
// method
// * takes no parameter and returns a Savepoint object.
// *
// * Input: None.
// * Returns: Setpoint Object - used to roll back to this point in time.
// *
// * NOTE: This is an unsupported function, calling it will cause an
// * unsupported exception to be thown.
// *
//**************************************************************************
// *
public Savepoint setSavepoint() throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_setSavepoint_V].methodEntry();
try {
clearWarnings();
Messages.throwUnsupportedFeatureException(locale_, "setSavepoint");
return null;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setSavepoint_V].methodExit();
}
}
/*
* RFE: Connection synchronization setTransactionIsolation() is now
* synchronized.
*/
public synchronized void setTransactionIsolation(int level)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "setTransactionIsolation(" + level + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_setTransactionIsolation].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_setTransactionIsolation].methodParameters("level="
+ level);
try {
clearWarnings();
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
switch (level) {
case TRANSACTION_NONE:
case TRANSACTION_READ_UNCOMMITTED:
case TRANSACTION_READ_COMMITTED:
case TRANSACTION_REPEATABLE_READ:
case TRANSACTION_SERIALIZABLE:
// Check if connection is open
setTransactionIsolation(server_, getDialogueId(),
mapTxnIsolation(level));
transactionIsolation_ = level;
updateConnectionReusability(SQL_SET_TRANSACTION);
break;
default:
throw Messages.createSQLException(locale_,
"invalid_transaction_isolation", null);
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setTransactionIsolation].methodExit();
}
}
// JDK 1.2
public void setTypeMap(java.util.Map<String, Class<?>> map)
throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "setTypeMap(" + map + ")");
if (out_ != null)
out_.println(getTraceId() + "setTypeMap(" + map + ")");
if (JdbcDebugCfg.entryActive)
debug[methodId_setTypeMap].methodEntry();
try {
clearWarnings();
userMap_ = map;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_setTypeMap].methodExit();
}
}
public synchronized void begintransaction() throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_begintransaction].methodEntry();
try {
int txid;
if (isClosed_)
throw Messages.createSQLException(locale_,
"invalid_connection", null);
if (getTxid() != 0)
throw Messages.createSQLException(locale_,
"invalid_transaction_state", null);
txid = beginTransaction(server_, getDialogueId());
if (txid != 0) {
setTxid_(txid);
autoCommit_ = false;
/*
* This flag was introduced to resolve the problem with BEGIN
* WORK COMMIT WORK and ROLLBACK WORK in SQLJ clause. The
* autoCommit flag set to false by SQLJ BEGIN WORK should to
* reset to true in SQLJ COMMIT WORK and ROLLBACK WORK.
*/
beginTransFlag_ = true;
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_begintransaction].methodExit();
}
}
// Other methods
private int mapTxnIsolation(int level) {
if (JdbcDebugCfg.entryActive)
debug[methodId_mapTxnIsolation].methodEntry();
if (JdbcDebugCfg.traceActive)
debug[methodId_mapTxnIsolation].methodParameters("level=" + level);
try {
int isolationLevel;
switch (level) {
case TRANSACTION_NONE: // May be we default to SQL/MX default
isolationLevel = SQL_TXN_READ_COMMITTED;
break;
case TRANSACTION_READ_COMMITTED:
isolationLevel = SQL_TXN_READ_COMMITTED;
break;
case TRANSACTION_READ_UNCOMMITTED:
isolationLevel = SQL_TXN_READ_UNCOMMITTED;
break;
case TRANSACTION_REPEATABLE_READ:
isolationLevel = SQL_TXN_REPEATABLE_READ;
break;
case TRANSACTION_SERIALIZABLE:
isolationLevel = SQL_TXN_SERIALIZABLE;
break;
default:
isolationLevel = SQL_TXN_READ_COMMITTED;
break;
}
return isolationLevel;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_mapTxnIsolation].methodExit();
}
}
long getNextRSCount() {
return ++rsCount_;
}
/*
* RFE: Connection synchronization gcStmts()is now synchronized.
*/
synchronized void gcStmts() {
if (JdbcDebugCfg.entryActive)
debug[methodId_gcStmts].methodEntry();
try {
Reference pRef;
//Venu changed stmtId from int to long for 64 bit
long stmtId;
Long stmtObject;
while ((pRef = refQ_.poll()) != null) {
Object obj = refToStmt_.get(pRef);
if (obj != null) {
stmtObject = (Long)obj;
// All PreparedStatement objects are added to HashMap
// Only Statement objects that produces ResultSet are added
// to
// HashMap
// Hence stmtLabel could be null
if (stmtObject != null) {
stmtId = stmtObject.intValue();
try {
SQLMXStatement.close(server_, getDialogueId(),
stmtId, true);
} catch (SQLException e) {
}finally {
refToStmt_.remove(pRef);
}
}
}
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_gcStmts].methodExit();
}
}
/*
* RFE: Connection synchronization removeElement()is now synchronized.
*/
synchronized void removeElement(SQLMXStatement stmt) {
if (JdbcDebugCfg.entryActive)
debug[methodId_removeElement_L].methodEntry();
try {
// if (stmt.pRef_.isEnqueued())
// don't know what to do
refToStmt_.remove(stmt.pRef_);
stmt.pRef_.clear();
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_removeElement_L].methodExit();
}
}
/*
* RFE: Connection synchronization addElement()is now synchronized.
*/
synchronized void addElement(SQLMXStatement stmt) {
if (JdbcDebugCfg.entryActive)
debug[methodId_addElement].methodEntry();
try {
//venu changed from Int to Long
refToStmt_.put(stmt.pRef_, new Long(stmt.stmtId_));
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_addElement].methodExit();
}
}
/*
* RFE: Connection synchronization connectInit() is now synchronized.
*/
synchronized void connectInit() throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_connectInit].methodEntry();
// Big Num Changes
//Current tx = new Current();
//int status =0;
try {
if (!connectInitialized_) {
try {
connectInit(server_, getDialogueId(), catalog_, schema_,
isReadOnly_, autoCommit_,
mapTxnIsolation(transactionIsolation_),
loginTimeout_, queryTimeout_,
statisticsIntervalTime_, statisticsLimitTime_, statisticsType_, programStatisticsEnabled_, statisticsSqlPlanEnabled_
);
if (iso88591EncodingOverride_ != null)
setCharsetEncodingOverride(server_, getDialogueId(),
SQLMXDesc.SQLCHARSETCODE_ISO88591,
iso88591EncodingOverride_);
} catch (SQLException e) {
if (pc_ != null)
pc_.sendConnectionErrorEvent(e);
else
close(true, true);
throw e;
}
connectInitialized_ = true;
}
}
finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_connectInit].methodExit();
}
}
void removeElement() {
if (JdbcDebugCfg.entryActive)
debug[methodId_removeElement_V].methodEntry();
try {
if (ds_ != null) {
ds_.weakConnection.removeElement(this);
ds_ = null;
} else if (pc_ != null) {
pc_.removeElement(this);
pc_ = null;
} else {
driver_.weakConnection.removeElement(this);
driver_ = null;
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_removeElement_V].methodExit();
}
}
/*
* RFE: Connection synchronization close() is now synchronized.
*/
synchronized void close(boolean hardClose, boolean sendEvents)
throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_close_Z].methodEntry(JdbcDebug.debugLevelPooling);
if (JdbcDebugCfg.traceActive)
debug[methodId_close_Z].methodParameters("hardClose=" + hardClose
+ ", sendEvents=" + sendEvents);
try {
clearWarnings();
if (!hardClose) {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() + "close()"+" Connection logically closed");
out_.println(getTraceId() + "close(hardClose="+hardClose +",sendEvents="+sendEvents+")");
}
if (isClosed_)
return;
if (isStatementCachingEnabled()) {
Object[] csArray = null;
csArray = (prepStmtsInCache_.values()).toArray();
closePreparedStatementsAll();
//Venu changed the below line from int to Long for 64 bit
ArrayList<Long> stmtIds = new ArrayList<Long>(
refToStmt_.values());
//Venu changed the below line from Int to Long
ArrayList<Long> listOfStmtsClosed = new ArrayList<Long>();
/*
* List to store the Statement Id Pointer.
*/
// venu changed the below line from Int to Long
ArrayList<Long> listOfCachedPrepStmtIds = new ArrayList<Long>();
for (int nfor = 0; nfor < csArray.length; ++nfor) {
listOfCachedPrepStmtIds
.add(((CachedPreparedStatement) csArray[nfor])
.getPstmt_().stmtId_);
}
csArray = null;
for (int i = 0; i < stmtIds.size(); i++) {
/*
* If the Statement is not found in
* CachedPreparedStatements. Then Close it.
*/
if (!listOfCachedPrepStmtIds.contains(stmtIds.get(i))) {
try {
// getDialogueId()
SQLMXStatement.close(server_, getDialogueId(),
((Long) stmtIds.get(i)).intValue(),
true);
} catch (SQLException se) {
}finally {
/*
* Mark this Statement so that this Statement is
* removed from the Statement References table.
*/
listOfStmtsClosed.add(stmtIds.get(i));
}
}
}
listOfCachedPrepStmtIds.clear();
/*
* Remove the Statement marked (already closed) from the
* Statement Reference table.
*/
Set<WeakReference> ks = refToStmt_.keySet();
Iterator<WeakReference> iter = ks.iterator();
ArrayList<WeakReference> listOfPrefs = new ArrayList<WeakReference>();
int nfor = 0;
while (iter.hasNext()) {
WeakReference pRef = iter.next();
if (listOfStmtsClosed.contains(refToStmt_.get(pRef))) {
listOfPrefs.add(pRef);
}
}
for (nfor = 0; nfor < listOfPrefs.size(); ++nfor) {
refToStmt_.remove(listOfPrefs.get(nfor));
}
listOfPrefs.clear();
/*
* Clear off the Temp list.
*/
listOfStmtsClosed.clear();
} else {
// close all the statements
//venu changed the below line from Int to Long
ArrayList<Long> stmtIds = new ArrayList<Long>(
refToStmt_.values());
int size = stmtIds.size();
for (int i = 0; i < size; i++) {
try {
SQLMXStatement
.close(server_, getDialogueId(),
((Long) stmtIds.get(i))
.longValue(), true);
} catch (SQLException se) {
// Ignore any exception and proceed to the next
// statement
}
}
refToStmt_.clear();
}
// Need to logically close the statement
// Rollback the Transaction independent of autoCommit mode
if (getTxid() != 0) {
try {
rollback(server_, getDialogueId(), getTxid());
} catch (SQLException se1) {
}
setTxid_(0);
}
pc_.logicalClose(sendEvents);
isClosed_ = true;
} else {
if (traceFlag_ >= T2Driver.POOLING_LVL) {
out_.println(getTraceId() +"close()"+" Connection Hard closed");
out_.println(getTraceId() + "close(hardClose="+hardClose +",sendEvents="+sendEvents+")");
}
if (getDialogueId() == 0)
return;
// close all the statements
Set<WeakReference> ks1 = refToStmt_.keySet();
Iterator<WeakReference> iter1 = ks1.iterator();
ArrayList<WeakReference> listOfStmts = new ArrayList<WeakReference> ();
while (iter1.hasNext()) {
WeakReference pRef = iter1.next();
listOfStmts.add(pRef);
}
for(int nfor=0;nfor<listOfStmts.size();nfor++) {
SQLMXStatement st=(SQLMXStatement)(listOfStmts.get(nfor)).get();
if (st != null) {
try {
st.close();
}
catch(SQLException se) {
// Ignore any exception and proceed to the next
// statement
}
}
}
refToStmt_.clear();
// Need to logically close the statement
// Rollback the Transaction independent of autoCommit mode
if (getTxid() != 0) {
try {
rollback(server_, getDialogueId(), getTxid());
} catch (SQLException se1) {
}
setTxid_(0);
}
if (isStatementCachingEnabled())
clearPreparedStatementsAll();
// Close the connection
try {
// getDialogueId(),setDialogueI_()
SQLMXConnection.close(server_, getDialogueId());
}finally {
isClosed_ = true;
keyForMap=this.incrementAndGetkeyForMapCounter();
mapOfClosedDialogs.put(keyForMap, getDialogueId());
setDialogueId(0);
removeElement();
}
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_close_Z].methodExit();
}
}
/*
* RFE: Connection synchronization reuse() is now synchronized.
*/
synchronized void reuse() throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_reuse].methodEntry(JdbcDebug.debugLevelPooling);
try {
if (connReuseBitMap_ != 0) {
connectReuse(server_, getDialogueId(), connReuseBitMap_,
dsCatalog_, dsSchema_,
TRANSACTION_READ_COMMITTED);
// Reset all connection attribute values
catalog_ = dsCatalog_;
schema_ = dsSchema_;
transactionIsolation_ = TRANSACTION_READ_COMMITTED;
connReuseBitMap_ = 0;
}
batchBindingSize_ = dsBatchBindingSize_;
autoCommit_ = true;
isReadOnly_ = false;
isClosed_ = false;
setTxid_(0);
transactionMode_ = dsTransactionMode_;
iso88591EncodingOverride_ = dsIso88591EncodingOverride_;
contBatchOnErrorval_ = dsContBatchOnError_; // RFE: Batch update
// improvements
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_reuse].methodExit();
}
}
void updateConnectionReusability(int stmtType) {
if (JdbcDebugCfg.entryActive)
debug[methodId_updateConnectionReusability]
.methodEntry(JdbcDebug.debugLevelPooling);
try {
switch (stmtType) {
case SQL_CONTROL:
connReuseBitMap_ |= SQL_CONTROL_FLAG;
break;
case SQL_SET_CATALOG:
connReuseBitMap_ |= SQL_SET_CATALOG_FLAG;
break;
case SQL_SET_SCHEMA:
connReuseBitMap_ |= SQL_SET_SCHEMA_FLAG;
break;
case SQL_SET_TRANSACTION:
connReuseBitMap_ |= SQL_SET_TRANSACTION_FLAG;
break;
}
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_updateConnectionReusability].methodExit();
}
}
//
// Extension method for WLS, this method gives the pooledConnection object
// associated with the given connection object.
public PooledConnection getPooledConnection() throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_getPooledConnection]
.methodEntry(JdbcDebug.debugLevelPooling);
try {
if (pc_ == null)
throw Messages.createSQLException(locale_,
"null_pooled_connection", null);
if (JdbcDebugCfg.traceActive)
debug[methodId_getPooledConnection].methodReturn("pc="
+ JdbcDebug.debugObjectStr(pc_));
return pc_;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getPooledConnection].methodExit();
}
}
static int mapTxnMode(String txnModeStr) {
if (JdbcDebugCfg.entryActive)
debug[methodId_mapTxnMode].methodEntry(JdbcDebug.debugLevelPooling);
try {
int txnMode;
if (txnModeStr.equalsIgnoreCase("internal") || txnModeStr.equals("1"))
txnMode = TXN_MODE_INTERNAL;
else if (txnModeStr.equalsIgnoreCase("mixed") || txnModeStr.equals("2"))
txnMode = TXN_MODE_MIXED;
else if (txnModeStr.equalsIgnoreCase("external") || txnModeStr.equals("3"))
txnMode = TXN_MODE_EXTERNAL;
else
txnMode = TXN_MODE_INVALID;
return txnMode;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_mapTxnMode].methodExit();
}
}
static String mapTxnModeToString(int txnMode) {
if (JdbcDebugCfg.entryActive)
debug[methodId_mapTxnModeToString]
.methodEntry(JdbcDebug.debugLevelPooling);
try {
String txnModeStr = null;
switch (txnMode) {
case 1:
txnModeStr = "internal";
break;
case 2:
txnModeStr = "mixed";
break;
case 3:
txnModeStr = "external";
break;
default:
txnModeStr = "mixed";
}
return txnModeStr;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_mapTxnModeToString].methodExit();
}
}
private void initSetDefaults() throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_initSetDefaults].methodEntry();
try {
clearWarnings();
autoCommit_ = true;
transactionIsolation_ = TRANSACTION_READ_COMMITTED;
isReadOnly_ = false;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_initSetDefaults].methodExit();
}
}
// Log the JDBC SQL statement and the STMTID to the idMapFile if the
// enableLog_ property is set.
private void printIdMapEntry(SQLMXStatement stmt) {
SQLMXDataSource.prWriter_.println("["
+ T2Driver.dateFormat.format(new java.util.Date()) + "] "
+ stmt.getStmtLabel_() + " (" + stmt.sql_.trim() + ")\n");
}
// Constructors with access specifier as "default"
SQLMXConnection(T2Driver driver, String url, T2Properties info)
throws SQLException {
super();
if (JdbcDebugCfg.entryActive)
debug[methodId_SQLMXConnection_LLL].methodEntry();
/* this.txIDPerThread = new ThreadLocal<Integer>() {
protected synchronized Integer initialValue() {
return new Integer(0);
}
};*/
try {
driver_ = driver;
url_ = url;
initSetDefaults();
t2props = info;
initConnectionProps(t2props);
// catalog_ = T2Driver.catalog_;
// schema_ = T2Driver.schema_;
// locale_ = T2Driver.locale_;
// batchBindingSize_ = T2Driver.batchBindingSize_;
//
// connectionTimeout_ = 60;
setDialogueId(connect(server_, uid_, pwd_));
if (getDialogueId() == 0)
return;
isClosed_ = false;
byteSwap_ = false;
refQ_ = new ReferenceQueue<SQLMXStatement>();
refToStmt_ = new HashMap<WeakReference, Long>();
pRef_ = new WeakReference<SQLMXConnection>(this, driver_.weakConnection.refQ_);
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_SQLMXConnection_LLL].methodExit();
}
}
SQLMXConnection(SQLMXDataSource ds, T2Properties properties)
throws SQLException {
super();
if (JdbcDebugCfg.entryActive)
debug[methodId_SQLMXConnection_LL_ds].methodEntry();
t2props = properties;
if(this.t2props.getLogWriter()!=null) {
this.setTracer(this.t2props.getLogWriter());
}
if (this.getTracer() != null)
this.getTracer().println(getTraceId() + "<Init>");
/*
this.txIDPerThread = new ThreadLocal<Integer>() {
protected synchronized Integer initialValue() {
return new Integer(0);
}
};*/
try {
ds_ = ds;
initSetDefaults();
// dsn_ = properties.getProperty("dataSourceName");
// dsn_ = properties.getDataSourceName();
// Obtain all the property info
// getProperties(properties);
initConnectionProps(t2props);
setDialogueId(connect(server_, uid_, pwd_));
if (getDialogueId() == 0)
return;
isClosed_ = false;
byteSwap_ = false;
setIsSpjRSFlag(getDialogueId(), t2props.isSpjrsOn());
refQ_ = new ReferenceQueue<SQLMXStatement>();
refToStmt_ = new HashMap<WeakReference, Long>();
pRef_ = new WeakReference<SQLMXConnection>(this,WeakConnection.refQ_);
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_SQLMXConnection_LL_ds].methodExit();
}
}
SQLMXConnection(SQLMXPooledConnection poolConn, T2Properties info)
throws SQLException {
super(info);
if (JdbcDebugCfg.entryActive)
debug[methodId_SQLMXConnection_LL_pool]
.methodEntry(JdbcDebug.debugLevelPooling);
if (JdbcDebugCfg.traceActive)
debug[methodId_getProperties].methodParameters("poolConn="
+ JdbcDebug.debugObjectStr(poolConn) + ", info="
+ JdbcDebug.debugObjectStr(info));
t2props = info;
if(this.t2props.getTraceFile()!=null&&SQLMXDataSource.traceWriter_!=null) {
this.setTracer(SQLMXDataSource.traceWriter_);
}
if (this.getTracer() != null)
this.getTracer().println(getTraceId() + "<Init>");
/* this.txIDPerThread = new ThreadLocal<Integer>() {
protected synchronized Integer initialValue() {
return new Integer(0);
}
};*/
try {
pc_ = poolConn;
initSetDefaults();
// getProperties(info);
initConnectionProps(t2props);
setDialogueId(connect(server_, uid_, pwd_));
if (getDialogueId() == 0)
return;
isClosed_ = false;
byteSwap_ = false;
refQ_ = new ReferenceQueue<SQLMXStatement>();
refToStmt_ = new HashMap<WeakReference, Long>();
pRef_ = new WeakReference<SQLMXConnection>(this,
SQLMXPooledConnection.refQ_);
holdability_ = SQLMXResultSet.CLOSE_CURSORS_AT_COMMIT;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_SQLMXConnection_LL_pool].methodExit();
}
}
static String getCharsetEncodingCached(String server, long dialogueId,
int charset, String encodingOverride) throws SQLException {
if (JdbcDebugCfg.entryActive)
debug[methodId_getCharsetEncodingCached]
.methodEntry(JdbcDebug.debugLevelPooling);
try {
if ((server == getCharsetEncodingCached_server)
&& (dialogueId == getCharsetEncodingCached_dialogueId)
&& (charset == getCharsetEncodingCached_charset)
&& (encodingOverride == getCharsetEncodingCached_encodingOverride))
return getCharsetEncodingCached_encoding;
getCharsetEncodingCached_encoding = getCharsetEncoding(server,
dialogueId, charset, encodingOverride);
getCharsetEncodingCached_server = server;
getCharsetEncodingCached_dialogueId = dialogueId;
getCharsetEncodingCached_charset = charset;
getCharsetEncodingCached_encodingOverride = encodingOverride;
return getCharsetEncodingCached_encoding;
}finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getCharsetEncodingCached].methodExit();
}
}
public static boolean getSqlStmtType2(String str) {
if ( getSqlStmtType(str.toUpperCase()) == TYPE_INSERT_PARAM
|| getSqlStmtType(str.toUpperCase()) == TYPE_INSERT
|| getSqlStmtType(str.toUpperCase()) == TYPE_UPDATE
|| getSqlStmtType(str.toUpperCase()) == TYPE_DELETE
)
{
return true;
} else {
return false;
}
}
static short getSqlStmtType(String str) {
//
// Kludge to determin if the type of statement.
//
String tokens[] = str.split("[^a-zA-Z]+", 3);
short rt1 = TYPE_UNKNOWN;
String str3 = "";
//
// If there are no separators (i.e. no spaces, {, =, etc.) in front of
// the
// first token, then the first token is the key word we are looking for.
// Else, the first token is an empty string (i.e. split thinks the first
// token is the empty string followed by a separator), and the second
// token is the key word we are looking for.
//
if (tokens[0].length() > 0) {
str3 = tokens[0].toUpperCase();
} else {
str3 = tokens[1].toUpperCase();
}
if ((str3.equals("SELECT")) || (str3.equals("SHOWSHAPE"))
|| (str3.equals("INVOKE")) || (str3.equals("SHOWCONTROL"))
|| (str3.equals("SHOWPLAN"))) {
rt1 = TYPE_SELECT;
} else if (str3.equals("UPDATE")) {
rt1 = TYPE_UPDATE;
} else if (str3.equals("DELETE")) {
rt1 = TYPE_DELETE;
} else if (str3.equals("INSERT") || (str.equals("UPSERT"))) {
if (str.indexOf('?') == -1) {
rt1 = TYPE_INSERT;
} else {
rt1 = TYPE_INSERT_PARAM;
}
} else if (str3.equals("EXPLAIN")) {
rt1 = TYPE_EXPLAIN;
} else if (str3.equals("CREATE")) {
rt1 = TYPE_CREATE;
} else if (str3.equals("GRANT")) {
rt1 = TYPE_GRANT;
} else if (str3.equals("DROP")) {
rt1 = TYPE_DROP;
} else if (str3.equals("CALL")) {
rt1 = TYPE_CALL;
} else if (str3.equals("EXPLAIN")) {
rt1 = TYPE_EXPLAIN;
} else if (str3.equals("CONTROL")) {
rt1 = TYPE_CONTROL;
} else {
rt1 = TYPE_UNKNOWN;
}
return rt1;
}
// Native methods
private native void setCatalog(String server, long dialogueId, String Catalog);
private native void setTransactionIsolation(String server, long dialogueId,
int level);
private native void setAutoCommit(String server, long dialogueId, boolean autoCommit);
// SPJRS
private native void setIsSpjRSFlag(long dialogueId, boolean isSpjrsOn);
// private native void setReadOnly(String server, int dialogueId, boolean
// readOnly);
private native void connectInit(String server, long dialogueId,
String catalog, String schema, boolean isReadOnly, boolean autoCommit,
int transactionIsolation, int loginTimeout, int queryTimeout,
int statisticsIntervalTime_, int statisticsLimitTime_, String statisticsType_, String programStatisticsEnabled_, String statisticsSqlPlanEnabled_) throws SQLException;
private native void connectReuse(String server, long dialogueId,
int conResetValue, String catalog, String schema,
int transactionIsolation) throws SQLException;
private native long connect(String server, String uid, String pwd);
static native void close(String server, long dialogueId) throws SQLException;
private native void commit(String server, long dialogueId, int txid)
throws SQLException;
private native void rollback(String server, long dialogueId, int txid)
throws SQLException;
private native int beginTransaction(String server, long dialogueId);
static native String getCharsetEncoding(String server, long dialogueId,
int charset, String encodingOverride) throws SQLException;
native void setCharsetEncodingOverride(String server, long dialogueId,
int charset, String encodingOverride) throws SQLException;
public void setTxid_(int txid_) {
this.txid_ = txid_;
// this.txIDPerThread.set(new Integer(txid_));
}
public int getTxid() {
return txid_;
// return this.txIDPerThread.get().intValue();
}
public void setDialogueId(long dialogueId_) throws SQLException {
this.dialogueId_ = dialogueId_;
}
public long getDialogueId() throws SQLException {
if(dialogueId_ != 0) {
if(mapOfClosedDialogs.containsKey(this.keyForMap)) {
throw new SQLException(Long.toHexString(mapOfClosedDialogs.get(this.keyForMap)) + " Connection is already closed.");
}
}
return dialogueId_;
}
/**
* @param tracer the tracer to set
*/
public void setTracer(PrintWriter tracer) {
setTraceId(org.apache.trafodion.jdbc.t2.T2Driver.traceText
+ org.apache.trafodion.jdbc.t2.T2Driver.dateFormat.format(new Date())
+ "]:["
+ Thread.currentThread()
+ "]:["
+ System.identityHashCode(this)
+ "]:"
+ this.getClass().getName().substring(
org.apache.trafodion.jdbc.t2.T2Driver.REMOVE_PKG_NAME, this.getClass().getName()
.length()) + ".");
this.out_ = tracer;
}
/**
* @return the tracer
*/
public PrintWriter getTracer() {
return out_;
}
public void initConnectionProps(T2Properties info) {
dsn_ = info.getDataSourceName();
transactionMode_ = mapTxnMode(info.getTransactionMode());
catalog_ = info.getCatalog();
schema_ = info.getSchema();
inlineLobChunkSize_ = info.getInlineLobChunkSize();
lobChunkSize_ = info.getLobChunkSize();
String lang = info.getLanguage();
if (lang == null)
locale_ = Locale.getDefault();
else {
if (lang.equalsIgnoreCase("ja"))
locale_ = new Locale("ja", "", "");
else if (lang.equalsIgnoreCase("en"))
locale_ = new Locale("en", "", "");
else
locale_ = Locale.getDefault();
}
batchBindingSize_ = info.getBatchBinding();
connectionTimeout_ = 60;
loginTimeout_ = info.getLoginTimeout();
contBatchOnError_ = info.getContBatchOnError();
iso88591EncodingOverride_ = info.getIso88591EncodingOverride();
//Publishing
statisticsIntervalTime_ = info.getStatisticsIntervalTime();
statisticsLimitTime_ = info.getStatisticsLimitTime();
statisticsType_ = info.getStatisticsType();
programStatisticsEnabled_ = info.getProgramStatisticsEnabled();
statisticsSqlPlanEnabled_ = info.getStatisticsSqlPlanEnabled();
dsCatalog_ = catalog_;
dsSchema_ = schema_;
dsBatchBindingSize_ = batchBindingSize_;
dsTransactionMode_ = transactionMode_;
dsIso88591EncodingOverride_ = iso88591EncodingOverride_;
dsContBatchOnError_ = contBatchOnErrorval_;// RFE: Batch update
// The enableLog_ flag is used to log SQL STMTIDs and their SQL strings
// if the
// enableLog and idMapFile system properties are not null, and the
// enableLog
// system property is set to "on".
if ((info.getEnableLog() != null) && (info.getIdMapFile() != null) && (info.getEnableLog().equalsIgnoreCase("on"))) {
synchronized (SQLMXDataSource.class) {
if (SQLMXDataSource.prWriter_ == null) {
try {
SQLMXDataSource.prWriter_ = new PrintWriter(new FileOutputStream(info.getIdMapFile(), true), true);
} catch (java.io.IOException e) {
SQLMXDataSource.prWriter_ = new PrintWriter(System.err, true);
}
}
}
}
}
//Jaime
public synchronized long incrementAndGetkeyForMapCounter() {
return ++keyForMapCounter;
}
public int getInlineLobChunkSize()
{
return inlineLobChunkSize_;
}
public int getLobChunkSize()
{
return lobChunkSize_;
}
public static final int SQL_TXN_READ_UNCOMMITTED = 1;
public static final int SQL_TXN_READ_COMMITTED = 2;
public static final int SQL_TXN_REPEATABLE_READ = 4;
public static final int SQL_TXN_SERIALIZABLE = 8;
public static final int TXN_MODE_INVALID = 0;
public static final int TXN_MODE_INTERNAL = 1;
public static final int TXN_MODE_MIXED = 2;
public static final int TXN_MODE_EXTERNAL = 3;
public static final String UCS_STR = "UCS2";
// Added the following for Connection pooling enhancement (Amena).
// {Note: These must match what is defined in sqlcli.h}
public static final int SQL_CONTROL = 9;
public static final int SQL_SET_TRANSACTION = 10;
public static final int SQL_SET_CATALOG = 11;
public static final int SQL_SET_SCHEMA = 12;
public static final int SQL_CONTROL_FLAG = 0x0008;
public static final int SQL_SET_CATALOG_FLAG = 0x0004;
public static final int SQL_SET_SCHEMA_FLAG = 0x0002;
public static final int SQL_SET_TRANSACTION_FLAG = 0x0001;
// Fields
static long rsCount_;
boolean beginTransFlag_ = false;
String server_;
String dsn_;
boolean autoCommit_;
String catalog_;
String schema_;
int transactionIsolation_;
boolean isClosed_;
boolean isReadOnly_;
String url_;
String uid_;
String pwd_;
int loginTimeout_;
int queryTimeout_;
int connectionTimeout_;
int inlineLobChunkSize_;
int lobChunkSize_;
private long dialogueId_;
int hClosestmtCount=0;
int lClosestmtCount=0;
int pStmtCount=0;
//Publishing
int statisticsIntervalTime_;
int statisticsLimitTime_;
String statisticsType_;
String programStatisticsEnabled_;
String statisticsSqlPlanEnabled_;
boolean byteSwap_;
private int txid_;
//ThreadLocal<Integer> txIDPerThread;
Map<String, Class<?>> userMap_;
Locale locale_;
ReferenceQueue<SQLMXStatement> refQ_;
HashMap<WeakReference, Long> refToStmt_;
boolean connectInitialized_;
int holdability_;
int batchBindingSize_;
String contBatchOnError_;
boolean contBatchOnErrorval_;
WeakReference<SQLMXConnection> pRef_;
SQLMXDataSource ds_;
SQLMXPooledConnection pc_;
T2Driver driver_;
T2Properties t2props;
int transactionMode_;
String iso88591EncodingOverride_;
String dsCatalog_;
String dsSchema_;
// Bit-mapped value that corresponds to what SQL connection
// attribute statements that have been executed within the connection
// context
int connReuseBitMap_;
// Cache area for character set
static String getCharsetEncodingCached_server;
static long getCharsetEncodingCached_dialogueId;
static int getCharsetEncodingCached_charset;
static String getCharsetEncodingCached_encodingOverride;
static String getCharsetEncodingCached_encoding;
private static int methodId_close_V = 0;
private static int methodId_close_Z = 1;
private static int methodId_commit = 2;
private static int methodId_createStatement = 3;
private static int methodId_createStatement_II = 4;
private static int methodId_createStatement_III = 5;
private static int methodId_getAutoCommit = 6;
private static int methodId_getCatalog = 7;
private static int methodId_getHoldability = 8;
private static int methodId_getMetaData = 9;
private static int methodId_getTransactionIsolation = 10;
private static int methodId_getTypeMap = 11;
private static int methodId_isClosed = 12;
private static int methodId_isReadOnly = 13;
private static int methodId_nativeSQL = 14;
private static int methodId_prepareCall_L = 15;
private static int methodId_prepareCall_LII = 16;
private static int methodId_prepareCall_LIII = 17;
private static int methodId_prepareStatement_L = 18;
private static int methodId_prepareStatement_LI = 19;
private static int methodId_prepareStatement_LI_array = 20;
private static int methodId_prepareStatement_LL_array = 21;
private static int methodId_prepareStatement_LII = 22;
private static int methodId_prepareStatement_LIII = 23;
private static int methodId_releaseSavepoint = 24;
private static int methodId_rollback_V = 25;
private static int methodId_rollback_L = 26;
private static int methodId_setAutoCommit = 27;
private static int methodId_setCatalog = 28;
private static int methodId_setHoldability = 29;
private static int methodId_setReadOnly = 30;
private static int methodId_setSavepoint_L = 31;
private static int methodId_setSavepoint_V = 32;
private static int methodId_setTransactionIsolation = 33;
private static int methodId_setTypeMap = 34;
private static int methodId_begintransaction = 35;
private static int methodId_mapTxnIsolation = 36;
private static int methodId_gcStmts = 37;
private static int methodId_removeElement_L = 38;
private static int methodId_removeElement_V = 39;
private static int methodId_addElement = 40;
private static int methodId_connectInit = 41;
private static int methodId_reuse = 42;
private static int methodId_updateConnectionReusability = 43;
private static int methodId_getDataLocator = 44;
private static int methodId_getPooledConnection = 45;
private static int methodId_getProperties = 46;
private static int methodId_SQLMXConnection_LLL = 47;
private static int methodId_SQLMXConnection_LL_ds = 48;
private static int methodId_SQLMXConnection_LL_pool = 49;
private static int methodId_mapTxnMode = 50;
private static int methodId_mapTxnModeToString = 51;
private static int methodId_initSetDefaults = 52;
private static int methodId_getCharsetEncodingCached = 53;
private static int methodId_getSchema = 54;
private static int totalMethodIds = 55;
private static JdbcDebug[] debug;
static {
String className = "SQLMXConnection";
if (JdbcDebugCfg.entryActive) {
debug = new JdbcDebug[totalMethodIds];
debug[methodId_close_V] = new JdbcDebug(className, "close_V");
debug[methodId_close_Z] = new JdbcDebug(className, "close_Z");
debug[methodId_commit] = new JdbcDebug(className, "commit");
debug[methodId_createStatement] = new JdbcDebug(className,
"createStatement");
debug[methodId_createStatement_II] = new JdbcDebug(className,
"createStatement");
debug[methodId_createStatement_III] = new JdbcDebug(className,
"createStatement");
debug[methodId_getAutoCommit] = new JdbcDebug(className,
"getAutoCommit");
debug[methodId_getCatalog] = new JdbcDebug(className, "getCatalog");
debug[methodId_getHoldability] = new JdbcDebug(className,
"getHoldability");
debug[methodId_getMetaData] = new JdbcDebug(className,
"getMetaData");
debug[methodId_getTransactionIsolation] = new JdbcDebug(className,
"getTransactionIsolation");
debug[methodId_getTypeMap] = new JdbcDebug(className, "getTypeMap");
debug[methodId_isClosed] = new JdbcDebug(className, "isClosed");
debug[methodId_isReadOnly] = new JdbcDebug(className, "isReadOnly");
debug[methodId_nativeSQL] = new JdbcDebug(className, "nativeSQL");
debug[methodId_prepareCall_L] = new JdbcDebug(className,
"prepareCall[L]");
debug[methodId_prepareCall_LII] = new JdbcDebug(className,
"prepareCall[LII]");
debug[methodId_prepareCall_LIII] = new JdbcDebug(className,
"prepareCall[LIII]");
debug[methodId_prepareStatement_L] = new JdbcDebug(className,
"prepareStatement[L]");
debug[methodId_prepareStatement_LI] = new JdbcDebug(className,
"prepareStatement[LI]");
debug[methodId_prepareStatement_LI_array] = new JdbcDebug(
className, "prepareStatement[LI_array]");
debug[methodId_prepareStatement_LL_array] = new JdbcDebug(
className, "prepareStatement[LL_array]");
debug[methodId_prepareStatement_LII] = new JdbcDebug(className,
"prepareStatement[LII]");
debug[methodId_prepareStatement_LIII] = new JdbcDebug(className,
"prepareStatement[LIII]");
debug[methodId_releaseSavepoint] = new JdbcDebug(className,
"releaseSavepoint");
debug[methodId_rollback_V] = new JdbcDebug(className, "rollback_V");
debug[methodId_rollback_L] = new JdbcDebug(className, "rollback_L");
debug[methodId_setAutoCommit] = new JdbcDebug(className,
"setAutoCommit");
debug[methodId_setCatalog] = new JdbcDebug(className, "setCatalog");
debug[methodId_setHoldability] = new JdbcDebug(className,
"setHoldability");
debug[methodId_setReadOnly] = new JdbcDebug(className,
"setReadOnly");
debug[methodId_setSavepoint_L] = new JdbcDebug(className,
"setSavepoint[L]");
debug[methodId_setSavepoint_V] = new JdbcDebug(className,
"setSavepoint[V]");
debug[methodId_setTransactionIsolation] = new JdbcDebug(className,
"setTransactionIsolation");
debug[methodId_setTypeMap] = new JdbcDebug(className, "setTypeMap");
debug[methodId_begintransaction] = new JdbcDebug(className,
"begintransaction");
debug[methodId_mapTxnIsolation] = new JdbcDebug(className,
"mapTxnIsolation");
debug[methodId_gcStmts] = new JdbcDebug(className, "gcStmts");
debug[methodId_removeElement_L] = new JdbcDebug(className,
"removeElement[L]");
debug[methodId_removeElement_V] = new JdbcDebug(className,
"removeElement[V]");
debug[methodId_addElement] = new JdbcDebug(className, "addElement");
debug[methodId_connectInit] = new JdbcDebug(className,
"connectInit");
debug[methodId_reuse] = new JdbcDebug(className, "reuse");
debug[methodId_updateConnectionReusability] = new JdbcDebug(
className, "updateConnectionReusability");
debug[methodId_getDataLocator] = new JdbcDebug(className,
"getDataLocator");
debug[methodId_getPooledConnection] = new JdbcDebug(className,
"getPooledConnection");
debug[methodId_getProperties] = new JdbcDebug(className,
"getProperties");
debug[methodId_SQLMXConnection_LLL] = new JdbcDebug(className,
"SQLMXConnection[LLL]");
debug[methodId_SQLMXConnection_LL_ds] = new JdbcDebug(className,
"SQLMXConnection[LL_ds]");
debug[methodId_SQLMXConnection_LL_pool] = new JdbcDebug(className,
"SQLMXConnection[LL_pool]");
debug[methodId_mapTxnMode] = new JdbcDebug(className, "mapTxnMode");
debug[methodId_mapTxnModeToString] = new JdbcDebug(className,
"mapTxnModeToString");
debug[methodId_initSetDefaults] = new JdbcDebug(className,
"initSetDefaults");
debug[methodId_getCharsetEncodingCached] = new JdbcDebug(className,
"getCharsetEncodingCached");
}
}
int dsBatchBindingSize_;
int dsTransactionMode_;
String dsIso88591EncodingOverride_;
boolean dsContBatchOnError_; // RFE: Batch update improvements
static final HashMap<Long, Long> mapOfClosedDialogs = new HashMap<Long, Long>();
static private long keyForMapCounter = 0;
private long keyForMap;
private PrintWriter tracer;
PreparedStatement clearCQD1;
PreparedStatement clearCQD2;
PreparedStatement clearCQD3;
public Object unwrap(Class iface) throws SQLException {
// TODO Auto-generated method stub
return null;
}
public boolean isWrapperFor(Class iface) throws SQLException {
// TODO Auto-generated method stub
return false;
}
public Clob createClob() throws SQLException {
return new SQLMXClob(this, null);
}
public Blob createBlob() throws SQLException {
return new SQLMXBlob(this, 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 {
// TODO Auto-generated method stub
}
public void setClientInfo(Properties properties)
throws SQLClientInfoException {
// TODO Auto-generated method stub
}
public String getClientInfo(String name) throws SQLException {
// TODO Auto-generated method stub
return null;
}
public Properties getClientInfo() throws SQLException {
// TODO Auto-generated method stub
return null;
}
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 {
// TODO Auto-generated method stub
}
public void abort(Executor executor) throws SQLException {
// TODO Auto-generated method stub
}
public void setNetworkTimeout(Executor executor, int milliseconds)
throws SQLException {
// TODO Auto-generated method stub
}
public int getNetworkTimeout() throws SQLException {
// TODO Auto-generated method stub
return 0;
}
public String getSchema() throws SQLException {
if (out_ != null)
out_.println(getTraceId() + "getSchema()");
if (JdbcDebugCfg.entryActive)
debug[methodId_getSchema].methodEntry();
try {
clearWarnings();
Statement s = null;
ResultSet rs = null;
String sch = null;
try {
s = this.createStatement();
rs = s.executeQuery("SHOWCONTROL DEFAULT SCHEMA, match full, no header");
rs.next();
sch = rs.getString(1);
if (sch.charAt(0) != '\"' && sch.indexOf('.') != -1) {
sch = sch.substring(sch.indexOf('.') + 1);
}
} catch (SQLException e) {
return schema_;
} finally {
if (rs != null)
rs.close();
if (s != null)
s.close();
}
return sch;
} finally {
if (JdbcDebugCfg.entryActive)
debug[methodId_getSchema].methodExit();
}
}
}