public C3P0PooledConnection(
Connection con,
ConnectionTester connectionTester,
boolean autoCommitOnClose,
boolean forceIgnoreUnresolvedTransactions,
ConnectionCustomizer cc,
String pdsIdt)
throws SQLException {
try {
if (cc != null) cc.onAcquire(con, pdsIdt);
} catch (Exception e) {
throw SqlUtils.toSQLException(e);
}
this.physicalConnection = con;
this.connectionTester = connectionTester;
this.autoCommitOnClose = autoCommitOnClose;
this.forceIgnoreUnresolvedTransactions = forceIgnoreUnresolvedTransactions;
this.supports_setTypeMap =
C3P0ImplUtils.supportsMethod(con, "setTypeMap", new Class[] {Map.class});
this.supports_setHoldability =
C3P0ImplUtils.supportsMethod(con, "setHoldability", new Class[] {int.class});
this.dflt_txn_isolation = con.getTransactionIsolation();
this.dflt_catalog = con.getCatalog();
this.dflt_holdability =
(supports_setHoldability ? con.getHoldability() : ResultSet.CLOSE_CURSORS_AT_COMMIT);
}
public Connection executeBatch() throws Sql2oException {
long start = System.currentTimeMillis();
try {
logExecution();
PreparedStatement statement = buildPreparedStatement();
connection.setBatchResult(statement.executeBatch());
this.currentBatchRecords = 0;
try {
connection.setKeys(this.returnGeneratedKeys ? statement.getGeneratedKeys() : null);
connection.setCanGetKeys(this.returnGeneratedKeys);
} catch (SQLException sqlex) {
throw new Sql2oException(
"Error while trying to fetch generated keys from database. If you are not expecting any generated keys, fix this error by setting the fetchGeneratedKeys parameter in the createQuery() method to 'false'",
sqlex);
}
} catch (Throwable e) {
this.connection.onException();
throw new Sql2oException("Error while executing batch operation: " + e.getMessage(), e);
} finally {
closeConnectionIfNecessary();
}
long end = System.currentTimeMillis();
logger.debug(
"total: {} ms; executed batch [{}]",
new Object[] {end - start, this.getName() == null ? "No name" : this.getName()});
return this.connection;
}
//
// Examine BLOBs and CLOBs.
//
private void vetLargeObjects(
Connection conn, HashSet<String> unsupportedList, HashSet<String> notUnderstoodList)
throws Exception {
Statement stmt = conn.createStatement();
stmt.execute("CREATE TABLE t (id INT PRIMARY KEY, " + "b BLOB(10), c CLOB(10))");
stmt.execute(
"INSERT INTO t (id, b, c) VALUES (1, "
+ "CAST ("
+ TestUtil.stringToHexLiteral("101010001101")
+ "AS BLOB(10)), CAST ('hello' AS CLOB(10)))");
ResultSet rs = stmt.executeQuery("SELECT id, b, c FROM t");
rs.next();
Blob blob = rs.getBlob(2);
Clob clob = rs.getClob(3);
vetObject(blob, unsupportedList, notUnderstoodList);
vetObject(clob, unsupportedList, notUnderstoodList);
stmt.close();
conn.rollback();
}
ConnectionWrapper(Connection con) {
this.connection =
(Connection)
Proxy.newProxyInstance(
con.getClass().getClassLoader(), con.getClass().getInterfaces(), this);
m_originConnection = con;
}
private void createConnection() throws SQLException {
connectionProvider = ConnectionProviderFactory.newConnectionProvider(properties);
connection = connectionProvider.getConnection();
if (!connection.getAutoCommit()) {
connection.commit();
connection.setAutoCommit(true);
}
}
//
// Examine Savepoints.
//
private void vetSavepoint(
Connection conn, HashSet<String> unsupportedList, HashSet<String> notUnderstoodList)
throws Exception {
conn.setAutoCommit(false);
Savepoint sp = conn.setSavepoint();
vetObject(sp, unsupportedList, notUnderstoodList);
conn.releaseSavepoint(sp);
}
/** 关闭连接 */
public static final void closeConnection() {
Connection conn = conns.get();
try {
if (conn != null && !conn.isClosed()) {
conn.setAutoCommit(true);
conn.close();
connectionContext.remove(Thread.currentThread().getId());
}
} catch (SQLException e) {
log.error("Unabled to close connection!!! ", e);
}
conns.set(null);
}
private void closeConnection() {
try {
if (statement != null) statement.close();
if (connection != null) {
JDBCExceptionReporter.logWarnings(connection.getWarnings());
connection.clearWarnings();
connectionProvider.closeConnection(connection);
connectionProvider.close();
}
} catch (Exception e) {
System.err.println("Could not close connection");
e.printStackTrace();
}
}
private Query(
Connection connection, String queryText, boolean returnGeneratedKeys, String[] columnNames) {
this.connection = connection;
this.returnGeneratedKeys = returnGeneratedKeys;
this.columnNames = columnNames;
this.setColumnMappings(connection.getSql2o().getDefaultColumnMappings());
this.caseSensitive = connection.getSql2o().isDefaultCaseSensitive();
paramNameToIdxMap = new HashMap<>();
parameters = new HashMap<>();
parsedQuery =
connection
.getSql2o()
.getQuirks()
.getSqlParameterParsingStrategy()
.parseSql(queryText, paramNameToIdxMap);
}
/** ************ private stuff ************** */
private void closeConnectionIfNecessary() {
try {
if (connection.autoClose) {
connection.close();
}
} catch (Exception ex) {
throw new Sql2oException("Error while attempting to close connection", ex);
}
}
public static final Connection getConnection() throws SQLException {
Connection conn = conns.get();
if (conn == null || conn.isClosed()) {
conn = _getConnection();
if (conn == null) throw new SQLException("Unabled to get connection.");
conns.set(conn);
// RequestContext ctx = RequestContext.get();
// connectionContext.put(
// Thread.currentThread().getId(),
// new ConnectionContext(new Exception(), (ctx != null) ? ctx
// .ip() : null, (ctx != null) ? ctx.uri() : null,
// (ctx != null) ? ctx.request().getParameterMap()
// : null));
}
return (show_sql && !Proxy.isProxyClass(conn.getClass()))
? new _DebugConnection(conn).getConnection()
: conn;
}
private PreparedStatement buildPreparedStatement(boolean allowArrayParameters) {
// array parameter handling
parsedQuery =
ArrayParameters.updateQueryAndParametersIndexes(
parsedQuery, paramNameToIdxMap, parameters, allowArrayParameters);
// prepare statement creation
if (preparedStatement == null) {
try {
if (columnNames != null && columnNames.length > 0) {
preparedStatement =
connection.getJdbcConnection().prepareStatement(parsedQuery, columnNames);
} else if (returnGeneratedKeys) {
preparedStatement =
connection
.getJdbcConnection()
.prepareStatement(parsedQuery, Statement.RETURN_GENERATED_KEYS);
} else {
preparedStatement = connection.getJdbcConnection().prepareStatement(parsedQuery);
}
} catch (SQLException ex) {
throw new Sql2oException(
String.format("Error preparing statement - %s", ex.getMessage()), ex);
}
connection.registerStatement(preparedStatement);
}
// parameters assignation to query
for (Map.Entry<String, ParameterSetter> parameter : parameters.entrySet()) {
for (int paramIdx : paramNameToIdxMap.get(parameter.getKey())) {
try {
parameter.getValue().setParameter(paramIdx, preparedStatement);
} catch (SQLException e) {
throw new RuntimeException(
String.format("Error adding parameter '%s' - %s", parameter.getKey(), e.getMessage()),
e);
}
}
}
// the parameters need to be cleared, so in case of batch, only new parameters will be added
parameters.clear();
return preparedStatement;
}
public void close() {
if (preparedStatement != null) {
connection.removeStatement(preparedStatement);
try {
this.getQuirks().closeStatement(preparedStatement);
} catch (Throwable ex) {
logger.warn("Could not close statement.", ex);
}
}
}
private void reset(boolean known_resolved_txn) throws SQLException {
ensureOkay();
C3P0ImplUtils.resetTxnState(
physicalConnection,
forceIgnoreUnresolvedTransactions,
autoCommitOnClose,
known_resolved_txn);
if (isolation_lvl_nondefault) {
physicalConnection.setTransactionIsolation(dflt_txn_isolation);
isolation_lvl_nondefault = false;
}
if (catalog_nondefault) {
physicalConnection.setCatalog(dflt_catalog);
catalog_nondefault = false;
}
if (holdability_nondefault) // we don't test if holdability is supported, 'cuz it can never go
// nondefault if it's not.
{
physicalConnection.setHoldability(dflt_holdability);
holdability_nondefault = false;
}
try {
physicalConnection.setReadOnly(false);
} catch (Throwable t) {
if (logger.isLoggable(MLevel.FINE))
logger.log(
MLevel.FINE,
"A Throwable occurred while trying to reset the readOnly property of our Connection to false!",
t);
}
try {
if (supports_setTypeMap) physicalConnection.setTypeMap(Collections.EMPTY_MAP);
} catch (Throwable t) {
if (logger.isLoggable(MLevel.FINE))
logger.log(
MLevel.FINE,
"A Throwable occurred while trying to reset the typeMap property of our Connection to Collections.EMPTY_MAP!",
t);
}
}
/** ** XAConnection interface *** */
public Connection getConnection() throws SQLException {
if (logger.logDebug()) debug("PGXAConnection.getConnection called");
Connection conn = super.getConnection();
// When we're outside an XA transaction, autocommit
// is supposed to be true, per usual JDBC convention.
// When an XA transaction is in progress, it should be
// false.
if (state == STATE_IDLE) conn.setAutoCommit(true);
/*
* Wrap the connection in a proxy to forbid application from
* fiddling with transaction state directly during an XA transaction
*/
ConnectionHandler handler = new ConnectionHandler(conn);
return (Connection)
Proxy.newProxyInstance(
getClass().getClassLoader(),
new Class[] {Connection.class, PGConnection.class},
handler);
}
/**
* 初始化连接池
*
* @param props
* @param show_sql
*/
private static final void initDataSource(Properties dbProperties) {
try {
if (dbProperties == null) {
dbProperties = new Properties();
dbProperties.load(DBManager.class.getResourceAsStream(CONFIG_PATH));
}
// Class.forName(dbProperties.getProperty("jdbc.driverClass"));
for (Object key : dbProperties.keySet()) {
String skey = (String) key;
if (skey.startsWith("jdbc.")) {
String name = skey.substring(5);
cp_props.put(name, dbProperties.getProperty(skey));
if ("show_sql".equalsIgnoreCase(name)) {
show_sql = "true".equalsIgnoreCase(dbProperties.getProperty(skey));
}
}
}
dataSource = (DataSource) Class.forName(cp_props.getProperty("datasource")).newInstance();
if (dataSource.getClass().getName().indexOf("c3p0") > 0) {
// Disable JMX in C3P0
System.setProperty(
"com.mchange.v2.c3p0.management.ManagementCoordinator",
"com.mchange.v2.c3p0.management.NullManagementCoordinator");
}
log.info("Using DataSource : " + dataSource.getClass().getName());
BeanUtils.populate(dataSource, cp_props);
Connection conn = getConnection();
DatabaseMetaData mdm = conn.getMetaData();
log.info(
"Connected to " + mdm.getDatabaseProductName() + " " + mdm.getDatabaseProductVersion());
closeConnection();
} catch (Exception e) {
e.printStackTrace();
throw new DBException(e);
}
}
//
// Find all the methods for java.sql objects in the Connection which raise
// SQLFeatureNotSupportedException.
//
private void connectionWorkhorse(
Connection conn, HashSet<String> unsupportedList, HashSet<String> notUnderstoodList)
throws Exception {
vetSavepoint(conn, unsupportedList, notUnderstoodList);
vetLargeObjects(conn, unsupportedList, notUnderstoodList);
DatabaseMetaData dbmd = conn.getMetaData();
PreparedStatement ps = conn.prepareStatement("select * from sys.systables where tablename = ?");
ps.setString(1, "foo");
ParameterMetaData parameterMetaData = ps.getParameterMetaData();
ResultSet rs = ps.executeQuery();
ResultSetMetaData rsmd = rs.getMetaData();
Statement stmt = conn.createStatement();
CallableStatement cs = conn.prepareCall("CALL SYSCS_UTIL.SET_RUNTIMESTATISTICS(0)");
ParameterMetaData csmd = cs.getParameterMetaData();
//
// The vetObject() method calls all of the methods in these objects
// in a deterministic order, calling the close() method last.
// Inspect these objects in an order which respects the fact that
// the objects are closed as a result of calling vetObject().
//
vetObject(dbmd, unsupportedList, notUnderstoodList);
vetObject(stmt, unsupportedList, notUnderstoodList);
vetObject(csmd, unsupportedList, notUnderstoodList);
vetObject(cs, unsupportedList, notUnderstoodList);
vetObject(rsmd, unsupportedList, notUnderstoodList);
vetObject(rs, unsupportedList, notUnderstoodList);
vetObject(parameterMetaData, unsupportedList, notUnderstoodList);
vetObject(ps, unsupportedList, notUnderstoodList);
vetObject(conn, unsupportedList, notUnderstoodList);
// No need to close the objects. They were closed by vetObject().
}
public List getIdentityTables() {
// delete all the data in the jbpm tables
List jbpmTableNames = new ArrayList();
try {
createConnection();
ResultSet resultSet = connection.getMetaData().getTables("", "", null, null);
while (resultSet.next()) {
String tableName = resultSet.getString("TABLE_NAME");
if ((tableName != null)
&& (tableName.length() > 5)
&& (IDENTITY_TABLE_PREFIX.equalsIgnoreCase(tableName.substring(0, 5)))) {
jbpmTableNames.add(tableName);
}
}
} catch (SQLException e) {
throw new RuntimeException("couldn't get the jbpm table names");
} finally {
closeConnection();
}
return jbpmTableNames;
}
public Connection executeUpdate() {
long start = System.currentTimeMillis();
try {
logExecution();
PreparedStatement statement = buildPreparedStatement();
this.connection.setResult(statement.executeUpdate());
this.connection.setKeys(this.returnGeneratedKeys ? statement.getGeneratedKeys() : null);
connection.setCanGetKeys(this.returnGeneratedKeys);
} catch (SQLException ex) {
this.connection.onException();
throw new Sql2oException("Error in executeUpdate, " + ex.getMessage(), ex);
} finally {
closeConnectionIfNecessary();
}
long end = System.currentTimeMillis();
logger.debug(
"total: {} ms; executed update [{}]",
new Object[] {end - start, this.getName() == null ? "No name" : this.getName()});
return this.connection;
}
public void execute(String[] sqls) {
String sql = null;
String showSqlText = properties.getProperty("hibernate.show_sql");
boolean showSql = ("true".equalsIgnoreCase(showSqlText));
try {
createConnection();
statement = connection.createStatement();
for (int i = 0; i < sqls.length; i++) {
sql = sqls[i];
String delimitedSql = sql + getSqlDelimiter();
if (showSql) log.debug(delimitedSql);
statement.executeUpdate(delimitedSql);
}
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("couldn't execute sql '" + sql + "'", e);
} finally {
closeConnection();
}
}
/**
* Try to update the row with the given error. Flag a failure if a timeout occurs when not
* expected, and vice versa.
*
* @param id The id of the row to be updated
* @param timeoutExpected true if it is expected that the update times out
* @throws java.sql.SQLException
*/
private void executeParallelUpdate(int id, boolean timeoutExpected) throws SQLException {
Connection conn2 = openDefaultConnection();
Statement stmt2 = conn2.createStatement();
try {
stmt2.executeUpdate(
"update BLOBCLOB set BLOBDATA = " + "cast(X'FFFFFF' as blob) where ID=" + id);
stmt2.close();
conn2.commit();
conn2.close();
if (timeoutExpected) {
fail("FAIL - should have gotten lock timeout");
}
} catch (SQLException se) {
stmt2.close();
conn2.rollback();
conn2.close();
if (timeoutExpected) {
assertSQLState(LOCK_TIMEOUT, se);
} else {
throw se;
}
}
}
/**
* Returns the conn.
*
* @return Connection
*/
public Connection getConnection() {
return (Connection)
Proxy.newProxyInstance(
conn.getClass().getClassLoader(), conn.getClass().getInterfaces(), this);
}
// TODO: factor out repetitive debugging code
private synchronized void close(boolean known_invalid) throws SQLException {
// System.err.println("Closing " + this);
if (physicalConnection != null) {
try {
StringBuffer debugOnlyLog = null;
if (Debug.DEBUG && known_invalid) {
debugOnlyLog = new StringBuffer();
debugOnlyLog.append("[ exceptions: ");
}
Exception exc = cleanupUncachedActiveStatements();
if (Debug.DEBUG && exc != null) {
if (known_invalid) debugOnlyLog.append(exc.toString() + ' ');
else
logger.log(
MLevel.WARNING,
"An exception occurred while cleaning up uncached active Statements.",
exc);
// exc.printStackTrace();
}
try {
// we've got to use silentClose() rather than close() here,
// 'cuz if there's still an exposedProxy (say a user forgot to
// close his Connection) before we close, and we use regular (loud)
// close, we will try to check this dead or dying PooledConnection
// back into the pool. We only want to do this when close is called
// on user proxies, and the underlying PooledConnection might still
// be good. The PooledConnection itself should only be closed by the
// pool.
if (exposedProxy != null) exposedProxy.silentClose(known_invalid);
} catch (Exception e) {
if (Debug.DEBUG) {
if (known_invalid) debugOnlyLog.append(e.toString() + ' ');
else logger.log(MLevel.WARNING, "An exception occurred.", exc);
// e.printStackTrace();
}
exc = e;
}
try {
this.closeAll();
} catch (Exception e) {
if (Debug.DEBUG) {
if (known_invalid) debugOnlyLog.append(e.toString() + ' ');
else logger.log(MLevel.WARNING, "An exception occurred.", exc);
// e.printStackTrace();
}
exc = e;
}
try {
physicalConnection.close();
} catch (Exception e) {
if (Debug.DEBUG) {
if (known_invalid) debugOnlyLog.append(e.toString() + ' ');
else logger.log(MLevel.WARNING, "An exception occurred.", exc);
e.printStackTrace();
}
exc = e;
}
if (exc != null) {
if (known_invalid) {
debugOnlyLog.append(" ]");
if (Debug.DEBUG) {
// System.err.print("[DEBUG]" + this + ": while closing a PooledConnection known
// to be invalid, ");
// System.err.println(" some exceptions occurred. This is probably not a
// problem:");
// System.err.println( debugOnlyLog.toString() );
logger.fine(
this
+ ": while closing a PooledConnection known to be invalid, "
+ " some exceptions occurred. This is probably not a problem: "
+ debugOnlyLog.toString());
}
} else
throw new SQLException(
"At least one error occurred while attempting "
+ "to close() the PooledConnection: "
+ exc);
}
if (Debug.TRACE == Debug.TRACE_MAX)
logger.fine("C3P0PooledConnection closed. [" + this + ']');
// System.err.println("C3P0PooledConnection closed. [" + this + ']');
} finally {
physicalConnection = null;
}
}
}
public synchronized Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
if (OBJECT_METHODS.contains(m)) return m.invoke(this, args);
try {
String mname = m.getName();
if (activeConnection != null) {
if (mname.equals("rawConnectionOperation")) {
ensureOkay();
txn_known_resolved = false;
return doRawConnectionOperation((Method) args[0], args[1], (Object[]) args[2]);
} else if (mname.equals("setTransactionIsolation")) {
ensureOkay();
// don't modify txn_known_resolved
m.invoke(activeConnection, args);
int lvl = ((Integer) args[0]).intValue();
isolation_lvl_nondefault = (lvl != dflt_txn_isolation);
// System.err.println("updated txn isolation to " + lvl + ", nondefault level? " +
// isolation_lvl_nondefault);
return null;
} else if (mname.equals("setCatalog")) {
ensureOkay();
// don't modify txn_known_resolved
m.invoke(activeConnection, args);
String catalog = (String) args[0];
catalog_nondefault = ObjectUtils.eqOrBothNull(catalog, dflt_catalog);
return null;
} else if (mname.equals("setHoldability")) {
ensureOkay();
// don't modify txn_known_resolved
m.invoke(
activeConnection,
args); // will throw an exception if setHoldability() not supported...
int holdability = ((Integer) args[0]).intValue();
holdability_nondefault = (holdability != dflt_holdability);
return null;
} else if (mname.equals("createStatement")) {
ensureOkay();
txn_known_resolved = false;
Object stmt = m.invoke(activeConnection, args);
return createProxyStatement((Statement) stmt);
} else if (mname.equals("prepareStatement")) {
ensureOkay();
txn_known_resolved = false;
Object pstmt;
if (scache == null) {
pstmt = m.invoke(activeConnection, args);
return createProxyStatement((Statement) pstmt);
} else {
pstmt = scache.checkoutStatement(physicalConnection, m, args);
return createProxyStatement(true, (Statement) pstmt);
}
} else if (mname.equals("prepareCall")) {
ensureOkay();
txn_known_resolved = false;
Object cstmt;
if (scache == null) {
cstmt = m.invoke(activeConnection, args);
return createProxyStatement((Statement) cstmt);
} else {
cstmt = scache.checkoutStatement(physicalConnection, m, args);
return createProxyStatement(true, (Statement) cstmt);
}
} else if (mname.equals("getMetaData")) {
ensureOkay();
txn_known_resolved = false; // views of tables etc. might be txn dependent
DatabaseMetaData innerMd = activeConnection.getMetaData();
if (metaData == null) {
// exposedProxy is protected by C3P0PooledConnection.this' lock
synchronized (C3P0PooledConnection.this) {
metaData =
new SetManagedDatabaseMetaData(innerMd, activeMetaDataResultSets, exposedProxy);
}
}
return metaData;
} else if (mname.equals("silentClose")) {
// the PooledConnection doesn't have to be okay
doSilentClose(proxy, ((Boolean) args[0]).booleanValue(), this.txn_known_resolved);
return null;
} else if (mname.equals("close")) {
// the PooledConnection doesn't have to be okay
Exception e = doSilentClose(proxy, false, this.txn_known_resolved);
if (!connection_error_signaled) ces.fireConnectionClosed();
// System.err.println("close() called on a ProxyConnection.");
if (e != null) {
// System.err.print("user close exception -- ");
// e.printStackTrace();
throw e;
} else return null;
}
// else if ( mname.equals("finalize") ) //REMOVE THIS CASE -- TMP DEBUG
// {
// System.err.println("Connection apparently finalized!");
// return m.invoke( activeConnection, args );
// }
else {
ensureOkay();
// we've disabled setting txn_known_resolved to true, ever, because
// we failed to deal with the case that clients would work with previously
// acquired Statements and ResultSets after a commit(), rollback(), or setAutoCommit().
// the new non-reflective proxies have been modified to deal with this case.
// here, with soon-to-be-deprecated in "traditional reflective proxies mode"
// we are reverting to the conservative, always-presume-you-have-to-rollback
// policy.
// txn_known_resolved = ( mname.equals("commit") || mname.equals( "rollback" ) ||
// mname.equals( "setAutoCommit" ) );
txn_known_resolved = false;
return m.invoke(activeConnection, args);
}
} else {
if (mname.equals("close") || mname.equals("silentClose")) return null;
else if (mname.equals("isClosed")) return Boolean.TRUE;
else {
throw new SQLException("You can't operate on " + "a closed connection!!!");
}
}
} catch (InvocationTargetException e) {
Throwable convertMe = e.getTargetException();
SQLException sqle = handleMaybeFatalToPooledConnection(convertMe, proxy, false);
sqle.fillInStackTrace();
throw sqle;
}
}
void close() throws SQLException {
m_originConnection.close();
}
