This closes #2263
This commit is contained in:
Clebert Suconic
commit
6c44462557
|
|
@ -30,6 +30,7 @@ import java.util.concurrent.Executor;
|
|||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import org.apache.activemq.artemis.jdbc.store.logging.LoggingConnection;
|
||||
import org.apache.activemq.artemis.jdbc.store.sql.SQLProvider;
|
||||
import org.apache.activemq.artemis.journal.ActiveMQJournalLogger;
|
||||
import org.jboss.logging.Logger;
|
||||
|
|
@ -85,7 +86,11 @@ public abstract class AbstractJDBCDriver {
|
|||
}
|
||||
|
||||
public AbstractJDBCDriver(Connection connection, SQLProvider sqlProvider) {
|
||||
if (logger.isTraceEnabled() && !(connection instanceof LoggingConnection)) {
|
||||
this.connection = new LoggingConnection(connection, logger);
|
||||
} else {
|
||||
this.connection = connection;
|
||||
}
|
||||
this.sqlProvider = sqlProvider;
|
||||
this.networkTimeoutExecutor = null;
|
||||
this.networkTimeoutMillis = -1;
|
||||
|
|
@ -118,6 +123,11 @@ public abstract class AbstractJDBCDriver {
|
|||
if (dataSource != null) {
|
||||
try {
|
||||
connection = dataSource.getConnection();
|
||||
|
||||
if (logger.isTraceEnabled() && !(connection instanceof LoggingConnection)) {
|
||||
this.connection = new LoggingConnection(connection, logger);
|
||||
}
|
||||
|
||||
} catch (SQLException e) {
|
||||
logger.error(JDBCUtils.appendSQLExceptionDetails(new StringBuilder(), e));
|
||||
throw e;
|
||||
|
|
@ -132,6 +142,11 @@ public abstract class AbstractJDBCDriver {
|
|||
}
|
||||
final Driver dbDriver = getDriver(jdbcDriverClass);
|
||||
connection = dbDriver.connect(jdbcConnectionUrl, new Properties());
|
||||
|
||||
if (logger.isTraceEnabled() && !(connection instanceof LoggingConnection)) {
|
||||
this.connection = new LoggingConnection(connection, logger);
|
||||
}
|
||||
|
||||
if (connection == null) {
|
||||
throw new IllegalStateException("the driver: " + jdbcDriverClass + " isn't able to connect to the requested url: " + jdbcConnectionUrl);
|
||||
}
|
||||
|
|
@ -293,9 +308,13 @@ public abstract class AbstractJDBCDriver {
|
|||
|
||||
public final void setConnection(Connection connection) {
|
||||
if (this.connection == null) {
|
||||
if (logger.isTraceEnabled() && !(connection instanceof LoggingConnection)) {
|
||||
this.connection = new LoggingConnection(connection, logger);
|
||||
} else {
|
||||
this.connection = connection;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void setSqlProvider(SQLProvider sqlProvider) {
|
||||
this.sqlProvider = sqlProvider;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,436 @@
|
|||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package org.apache.activemq.artemis.jdbc.store.logging;
|
||||
|
||||
import java.sql.Array;
|
||||
import java.sql.Blob;
|
||||
import java.sql.CallableStatement;
|
||||
import java.sql.Clob;
|
||||
import java.sql.Connection;
|
||||
import java.sql.DatabaseMetaData;
|
||||
import java.sql.NClob;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.SQLClientInfoException;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.SQLWarning;
|
||||
import java.sql.SQLXML;
|
||||
import java.sql.Savepoint;
|
||||
import java.sql.Statement;
|
||||
import java.sql.Struct;
|
||||
import java.util.Arrays;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import java.util.concurrent.Executor;
|
||||
|
||||
import org.jboss.logging.Logger;
|
||||
|
||||
public class LoggingConnection implements Connection {
|
||||
|
||||
private final Connection connection;
|
||||
|
||||
private final String connectionID;
|
||||
|
||||
private Logger logger;
|
||||
|
||||
private Logger.Level level = Logger.Level.TRACE;
|
||||
|
||||
public LoggingConnection(Connection connection, Logger logger) {
|
||||
this.connection = connection;
|
||||
this.logger = logger;
|
||||
this.connectionID = LoggingUtil.getID(connection);
|
||||
}
|
||||
|
||||
public Connection getConnection() {
|
||||
return connection;
|
||||
}
|
||||
|
||||
public String getConnectionID() {
|
||||
return connectionID;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Statement createStatement() throws SQLException {
|
||||
LoggingStatement statement = new LoggingStatement(connection.createStatement(), logger);
|
||||
logger.logf(level, "%s.createStatement() = %s", connectionID, statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql) throws SQLException {
|
||||
LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql), logger);
|
||||
logger.logf(level, "%s.prepareStatement(%s) = %s", connectionID, sql, statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public CallableStatement prepareCall(String sql) throws SQLException {
|
||||
CallableStatement statement = connection.prepareCall(sql);
|
||||
logger.logf(level, "%s.prepareCall(%s) = %s", connectionID, sql, LoggingUtil.getID(statement));
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String nativeSQL(String sql) throws SQLException {
|
||||
String x = connection.nativeSQL(sql);
|
||||
logger.logf(level, "%s.nativeSQL(%s) = %s", connectionID, sql, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setAutoCommit(boolean autoCommit) throws SQLException {
|
||||
logger.logf(level, "%s.setAutoCommit(%s)", connectionID, autoCommit);
|
||||
connection.setAutoCommit(autoCommit);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getAutoCommit() throws SQLException {
|
||||
boolean x = connection.getAutoCommit();
|
||||
logger.logf(level, "%s.getAutoCommit() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void commit() throws SQLException {
|
||||
logger.logf(level, "%s.commit()", connectionID);
|
||||
connection.commit();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void rollback() throws SQLException {
|
||||
logger.logf(level, "%s.rollback()", connectionID);
|
||||
connection.rollback();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() throws SQLException {
|
||||
logger.logf(level, "%s.close()", connectionID);
|
||||
connection.close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isClosed() throws SQLException {
|
||||
boolean x = connection.isClosed();
|
||||
logger.logf(level, "%s.isClosed() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatabaseMetaData getMetaData() throws SQLException {
|
||||
DatabaseMetaData x = connection.getMetaData();
|
||||
logger.logf(level, "%s.getMetaData() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setReadOnly(boolean readOnly) throws SQLException {
|
||||
logger.logf(level, "%s.setReadOnly(%s)", connectionID, readOnly);
|
||||
connection.setReadOnly(readOnly);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isReadOnly() throws SQLException {
|
||||
boolean x = connection.isReadOnly();
|
||||
logger.logf(level, "%s.isReadOnly() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCatalog(String catalog) throws SQLException {
|
||||
logger.logf(level, "%s.setCatalog(%s)", connectionID, catalog);
|
||||
connection.setCatalog(catalog);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getCatalog() throws SQLException {
|
||||
String x = connection.getCatalog();
|
||||
logger.logf(level, "%s.getCatalog() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTransactionIsolation(int level) throws SQLException {
|
||||
logger.logf(this.level, "%s.setTransactionIsolation(%s)", connectionID, level);
|
||||
connection.setTransactionIsolation(level);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTransactionIsolation() throws SQLException {
|
||||
int x = connection.getTransactionIsolation();
|
||||
logger.logf(level, "%s.getTransactionIsolation() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public SQLWarning getWarnings() throws SQLException {
|
||||
SQLWarning x = connection.getWarnings();
|
||||
logger.logf(level, "%s.getWarnings() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearWarnings() throws SQLException {
|
||||
logger.logf(level, "%s.clearWarnings()", connectionID);
|
||||
connection.clearWarnings();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
|
||||
LoggingStatement statement = new LoggingStatement(connection.createStatement(resultSetType, resultSetConcurrency), logger);
|
||||
logger.logf(level, "%s.createStatement(%s, %s) = %s", connectionID, resultSetType, resultSetConcurrency, statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql,
|
||||
int resultSetType,
|
||||
int resultSetConcurrency) throws SQLException {
|
||||
LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, resultSetType, resultSetConcurrency), logger);
|
||||
logger.logf(level, "%s.prepareStatement(%s, %s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
|
||||
CallableStatement statement = connection.prepareCall(sql, resultSetType, resultSetConcurrency);
|
||||
logger.logf(level, "%s.createStatement(%s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, LoggingUtil.getID(statement));
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<String, Class<?>> getTypeMap() throws SQLException {
|
||||
Map<String, Class<?>> x = connection.getTypeMap();
|
||||
logger.logf(level, "%s.getTypeMap() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
|
||||
logger.logf(level, "%s.setTypeMap(%s)", connectionID, map);
|
||||
connection.setTypeMap(map);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setHoldability(int holdability) throws SQLException {
|
||||
logger.logf(level, "%s.setHoldability(%s)", connectionID, holdability);
|
||||
connection.setHoldability(holdability);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getHoldability() throws SQLException {
|
||||
int x = connection.getHoldability();
|
||||
logger.logf(level, "%s.getHoldability() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Savepoint setSavepoint() throws SQLException {
|
||||
Savepoint x = connection.setSavepoint();
|
||||
logger.logf(level, "%s.setSavepoint() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Savepoint setSavepoint(String name) throws SQLException {
|
||||
Savepoint x = connection.setSavepoint(name);
|
||||
logger.logf(level, "%s.setSavepoint(%s) = %s", connectionID, name, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void rollback(Savepoint savepoint) throws SQLException {
|
||||
logger.logf(level, "%s.rollback(%s)", connectionID, savepoint);
|
||||
connection.rollback(savepoint);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
|
||||
logger.logf(level, "%s.releaseSavepoint(%s)", connectionID, savepoint);
|
||||
connection.releaseSavepoint(savepoint);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Statement createStatement(int resultSetType,
|
||||
int resultSetConcurrency,
|
||||
int resultSetHoldability) throws SQLException {
|
||||
LoggingStatement statement = new LoggingStatement(connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability), logger);
|
||||
logger.logf(level, "%s.createStatement(%s, %s, %s) = %s", connectionID, resultSetType, resultSetConcurrency, resultSetHoldability, statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql,
|
||||
int resultSetType,
|
||||
int resultSetConcurrency,
|
||||
int resultSetHoldability) throws SQLException {
|
||||
LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability), logger);
|
||||
logger.logf(level, "%s.prepareStatement(%s, %s, %s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, resultSetHoldability, statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public CallableStatement prepareCall(String sql,
|
||||
int resultSetType,
|
||||
int resultSetConcurrency,
|
||||
int resultSetHoldability) throws SQLException {
|
||||
CallableStatement statement = connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
|
||||
logger.logf(level, "%s.prepareCall(%s, %s, %s, %s) = %s", connectionID, sql, resultSetType, resultSetConcurrency, resultSetHoldability, LoggingUtil.getID(statement));
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
|
||||
LoggingPreparedStatement preparedStatement = new LoggingPreparedStatement(connection.prepareStatement(sql, autoGeneratedKeys), logger);
|
||||
logger.logf(level, "%s.prepareStatement(%s, %s) = %s", connectionID, sql, autoGeneratedKeys, preparedStatement.getStatementID());
|
||||
return preparedStatement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
|
||||
LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, columnIndexes), logger);
|
||||
logger.logf(level, "%s.prepareStatement(%s, %s) = %s", connectionID, sql, Arrays.toString(columnIndexes), statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
|
||||
LoggingPreparedStatement statement = new LoggingPreparedStatement(connection.prepareStatement(sql, columnNames), logger);
|
||||
logger.logf(level, "%s.prepareStatement(%s, %s) = %s", connectionID, sql, Arrays.toString(columnNames), statement.getStatementID());
|
||||
return statement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Clob createClob() throws SQLException {
|
||||
Clob x = connection.createClob();
|
||||
logger.logf(level, "%s.createClob() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Blob createBlob() throws SQLException {
|
||||
Blob x = connection.createBlob();
|
||||
logger.logf(level, "%s.createBlob() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NClob createNClob() throws SQLException {
|
||||
NClob x = connection.createNClob();
|
||||
logger.logf(level, "%s.createNClob() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public SQLXML createSQLXML() throws SQLException {
|
||||
SQLXML x = connection.createSQLXML();
|
||||
logger.logf(level, "%s.createSQLXML() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isValid(int timeout) throws SQLException {
|
||||
boolean x = connection.isValid(timeout);
|
||||
logger.logf(level, "%s.isValid(%s) = %s", connectionID, timeout, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setClientInfo(String name, String value) throws SQLClientInfoException {
|
||||
logger.logf(level, "%s.setClientInfo(%s, %s)", connectionID, name, value);
|
||||
connection.setClientInfo(name, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setClientInfo(Properties properties) throws SQLClientInfoException {
|
||||
logger.logf(level, "%s.setClientInfo(%s)", connectionID, properties);
|
||||
connection.setClientInfo(properties);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getClientInfo(String name) throws SQLException {
|
||||
String x = connection.getClientInfo(name);
|
||||
logger.logf(level, "%s.getClientInfo(%s) = %s", connectionID, name, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Properties getClientInfo() throws SQLException {
|
||||
Properties x = connection.getClientInfo();
|
||||
logger.logf(level, "%s.getClientInfo() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
|
||||
Array x = connection.createArrayOf(typeName, elements);
|
||||
logger.logf(level, "%s.createArrayOf(%s, %s) = %s", connectionID, typeName, Arrays.toString(elements), x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
|
||||
Struct x = connection.createStruct(typeName, attributes);
|
||||
logger.logf(level, "%s.createStruct(%s, %s) = %s", connectionID, typeName, Arrays.toString(attributes), x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSchema(String schema) throws SQLException {
|
||||
logger.logf(level, "%s.setSchema(%s)", connectionID, schema);
|
||||
connection.setSchema(schema);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSchema() throws SQLException {
|
||||
String x = connection.getSchema();
|
||||
logger.logf(level, "%s.getSchema() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void abort(Executor executor) throws SQLException {
|
||||
logger.logf(level, "%s.abort(%s)", connectionID, executor);
|
||||
connection.abort(executor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
|
||||
logger.logf(level, "%s.setNetworkTimeout(%s, %d)", connectionID, executor, milliseconds);
|
||||
connection.setNetworkTimeout(executor, milliseconds);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getNetworkTimeout() throws SQLException {
|
||||
int x = connection.getNetworkTimeout();
|
||||
logger.logf(level, "%s.getNetworkTimeout() = %s", connectionID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> T unwrap(Class<T> iface) throws SQLException {
|
||||
T x = connection.unwrap(iface);
|
||||
logger.logf(level, "%s.unwrap(%s) = %s", connectionID, iface, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
||||
boolean x = connection.isWrapperFor(iface);
|
||||
logger.logf(level, "%s.isWrapperFor() = %s", connectionID, iface, x);
|
||||
return x;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,406 @@
|
|||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package org.apache.activemq.artemis.jdbc.store.logging;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.io.Reader;
|
||||
import java.math.BigDecimal;
|
||||
import java.net.URL;
|
||||
import java.sql.Array;
|
||||
import java.sql.Blob;
|
||||
import java.sql.Clob;
|
||||
import java.sql.Date;
|
||||
import java.sql.NClob;
|
||||
import java.sql.ParameterMetaData;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.Ref;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.ResultSetMetaData;
|
||||
import java.sql.RowId;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.SQLType;
|
||||
import java.sql.SQLXML;
|
||||
import java.sql.Time;
|
||||
import java.sql.Timestamp;
|
||||
import java.util.Calendar;
|
||||
|
||||
import org.jboss.logging.Logger;
|
||||
|
||||
public class LoggingPreparedStatement extends LoggingStatement implements PreparedStatement {
|
||||
|
||||
private final PreparedStatement preparedStatement;
|
||||
|
||||
public LoggingPreparedStatement(PreparedStatement preparedStatement, Logger logger) {
|
||||
super(preparedStatement, logger);
|
||||
this.preparedStatement = preparedStatement;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ResultSet executeQuery() throws SQLException {
|
||||
LoggingResultSet rs = new LoggingResultSet(preparedStatement.executeQuery(), logger);
|
||||
logger.logf(level, "%s.executeQuery() = %s", statementID, rs.getResultSetID());
|
||||
return rs;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int executeUpdate() throws SQLException {
|
||||
int i = preparedStatement.executeUpdate();
|
||||
logger.logf(level, "%s.executeUpdate() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNull(int parameterIndex, int sqlType) throws SQLException {
|
||||
logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, sqlType);
|
||||
preparedStatement.setNull(parameterIndex, sqlType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
|
||||
logger.logf(level, "%s.setBoolean(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setBoolean(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setByte(int parameterIndex, byte x) throws SQLException {
|
||||
logger.logf(level, "%s.setByte(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setByte(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setShort(int parameterIndex, short x) throws SQLException {
|
||||
logger.logf(level, "%s.setShort(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setShort(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setInt(int parameterIndex, int x) throws SQLException {
|
||||
logger.logf(level, "%s.setInt(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setInt(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLong(int parameterIndex, long x) throws SQLException {
|
||||
logger.logf(level, "%s.setLong(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setLong(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFloat(int parameterIndex, float x) throws SQLException {
|
||||
logger.logf(level, "%s.setFloat(%d, %f)", statementID, parameterIndex, x);
|
||||
preparedStatement.setFloat(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDouble(int parameterIndex, double x) throws SQLException {
|
||||
logger.logf(level, "%s.setDouble(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setDouble(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
|
||||
logger.logf(level, "%s.setBigDecimal(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setBigDecimal(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setString(int parameterIndex, String x) throws SQLException {
|
||||
logger.logf(level, "%s.setString(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setString(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBytes(int parameterIndex, byte[] x) throws SQLException {
|
||||
logger.logf(level, "%s.setBytes(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setBytes(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDate(int parameterIndex, Date x) throws SQLException {
|
||||
logger.logf(level, "%s.setDate(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setDate(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTime(int parameterIndex, Time x) throws SQLException {
|
||||
logger.logf(level, "%s.setTime(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setTime(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
|
||||
logger.logf(level, "%s.setTimestamp(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setTimestamp(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
|
||||
logger.logf(level, "%s.setAsciiStream(%d, %s, %d)", statementID, parameterIndex, x, length);
|
||||
preparedStatement.setAsciiStream(parameterIndex, x, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
|
||||
logger.logf(level, "%s.setUnicodeStream(%d, %s, %d)", statementID, parameterIndex, x, length);
|
||||
preparedStatement.setUnicodeStream(parameterIndex, x, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
|
||||
logger.logf(level, "%s.setBinaryStream(%d, %s, %d)", statementID, parameterIndex, x, length);
|
||||
preparedStatement.setBinaryStream(parameterIndex, x, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearParameters() throws SQLException {
|
||||
logger.logf(level, "%s.clearParameters()", statementID);
|
||||
preparedStatement.clearParameters();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
|
||||
logger.logf(level, "%s.setObject(%d, %s, %d)", statementID, parameterIndex, x, targetSqlType);
|
||||
preparedStatement.setObject(parameterIndex, x, targetSqlType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(int parameterIndex, Object x) throws SQLException {
|
||||
logger.logf(level, "%s.setObject(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute() throws SQLException {
|
||||
boolean b = preparedStatement.execute();
|
||||
logger.logf(level, "%s.execute() = %s", statementID, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addBatch() throws SQLException {
|
||||
logger.logf(level, "%s.addBatch()", statementID);
|
||||
preparedStatement.addBatch();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
|
||||
logger.logf(level, "%s.setCharacterStream(%d, %s, %d)", statementID, parameterIndex, reader, length);
|
||||
preparedStatement.setCharacterStream(parameterIndex, reader, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setRef(int parameterIndex, Ref x) throws SQLException {
|
||||
logger.logf(level, "%s.setRef(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setRef(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBlob(int parameterIndex, Blob x) throws SQLException {
|
||||
logger.logf(level, "%s.setBlob(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setBlob(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setClob(int parameterIndex, Clob x) throws SQLException {
|
||||
logger.logf(level, "%s.setClob(%d, %x)", statementID, parameterIndex, x);
|
||||
preparedStatement.setClob(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setArray(int parameterIndex, Array x) throws SQLException {
|
||||
logger.logf(level, "%s.setArray(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setArray(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ResultSetMetaData getMetaData() throws SQLException {
|
||||
ResultSetMetaData resultSetMetaData = preparedStatement.getMetaData();
|
||||
logger.logf(level, "%s.getMetaData() = %s", statementID, LoggingUtil.getID(resultSetMetaData));
|
||||
return resultSetMetaData;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
|
||||
logger.logf(level, "%s.setDate(%d, %s, %s)", statementID, parameterIndex, x, cal);
|
||||
preparedStatement.setDate(parameterIndex, x, cal);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
|
||||
logger.logf(level, "%s.setTime(%d, %s, %s)", statementID, parameterIndex, x, cal);
|
||||
preparedStatement.setTime(parameterIndex, x, cal);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
|
||||
logger.logf(level, "%s.setTimestamp(%d, %s, %s)", statementID, parameterIndex, x, cal);
|
||||
preparedStatement.setTimestamp(parameterIndex, x, cal);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
|
||||
logger.logf(level, "%s.setNull(%d, %d, %s)", statementID, parameterIndex, sqlType, typeName);
|
||||
preparedStatement.setNull(parameterIndex, sqlType, typeName);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setURL(int parameterIndex, URL x) throws SQLException {
|
||||
logger.logf(level, "%s.setURL(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setURL(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ParameterMetaData getParameterMetaData() throws SQLException {
|
||||
ParameterMetaData x = preparedStatement.getParameterMetaData();
|
||||
logger.logf(level, "%s.getParameterMetaData() = %s", statementID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setRowId(int parameterIndex, RowId x) throws SQLException {
|
||||
logger.logf(level, "%s.setRowId(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setRowId(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNString(int parameterIndex, String value) throws SQLException {
|
||||
logger.logf(level, "%s.setNString(%d, %s)", statementID, parameterIndex, value);
|
||||
preparedStatement.setNString(parameterIndex, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setNCharacterStream(%d, %s, %d)", statementID, parameterIndex, value, length);
|
||||
preparedStatement.setNCharacterStream(parameterIndex, value, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNClob(int parameterIndex, NClob value) throws SQLException {
|
||||
logger.logf(level, "%s.setNClob(%d, %s)", statementID, parameterIndex, value);
|
||||
preparedStatement.setNClob(parameterIndex, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setClob(%d, %s, %s)", statementID, parameterIndex, reader, length);
|
||||
preparedStatement.setClob(parameterIndex, reader, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setBlob(%d, %s, %d)", statementID, parameterIndex, inputStream, length);
|
||||
preparedStatement.setBlob(parameterIndex, inputStream, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setNClob(%d, %s, %d)", statementID, parameterIndex, reader, length);
|
||||
preparedStatement.setNClob(parameterIndex, reader, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
|
||||
logger.logf(level, "%s.setSQLXML(%d, %s)", statementID, parameterIndex, xmlObject);
|
||||
preparedStatement.setSQLXML(parameterIndex, xmlObject);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
|
||||
logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setAsciiStream(parameterIndex, x, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setNull(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setBinaryStream(parameterIndex, x, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
|
||||
logger.logf(level, "%s.setCharacterStream(%d, %s, %d)", statementID, parameterIndex, reader, length);
|
||||
preparedStatement.setCharacterStream(parameterIndex, reader, length);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
|
||||
logger.logf(level, "%s.setAsciiStream(%d, %d)", statementID, parameterIndex, x);
|
||||
preparedStatement.setAsciiStream(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
|
||||
logger.logf(level, "%s.setBinaryStream(%d, %s)", statementID, parameterIndex, x);
|
||||
preparedStatement.setBinaryStream(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
|
||||
logger.logf(level, "%s.setCharacterStream(%d, %s)", statementID, parameterIndex, reader);
|
||||
preparedStatement.setCharacterStream(parameterIndex, reader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
|
||||
logger.logf(level, "%s.setNCharacterStream(%d, %s)", statementID, parameterIndex, value);
|
||||
preparedStatement.setNCharacterStream(parameterIndex, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setClob(int parameterIndex, Reader reader) throws SQLException {
|
||||
logger.logf(level, "%s.setClob(%d, %s)", statementID, parameterIndex, reader);
|
||||
preparedStatement.setClob(parameterIndex, reader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
|
||||
logger.logf(level, "%s.setBlob(%d, %s)", statementID, parameterIndex, inputStream);
|
||||
preparedStatement.setBlob(parameterIndex, inputStream);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNClob(int parameterIndex, Reader reader) throws SQLException {
|
||||
logger.logf(level, "%s.setNClob(%d, %s)", statementID, parameterIndex, reader);
|
||||
preparedStatement.setNClob(parameterIndex, reader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(int parameterIndex, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException {
|
||||
logger.logf(level, "%s.setObject(%d, %s, %s, %d)", statementID, parameterIndex, x, targetSqlType, scaleOrLength);
|
||||
preparedStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(int parameterIndex, Object x, SQLType targetSqlType) throws SQLException {
|
||||
logger.logf(level, "%s.setObject(%d, %s, %d)", statementID, parameterIndex, x, targetSqlType);
|
||||
preparedStatement.setObject(parameterIndex, x, targetSqlType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long executeLargeUpdate() throws SQLException {
|
||||
long l = preparedStatement.executeLargeUpdate();
|
||||
logger.logf(level, "%s.executeLargeUpdate() = %s", statementID, l);
|
||||
return l;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,400 @@
|
|||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package org.apache.activemq.artemis.jdbc.store.logging;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.SQLWarning;
|
||||
import java.sql.Statement;
|
||||
import java.util.Arrays;
|
||||
|
||||
import org.jboss.logging.Logger;
|
||||
|
||||
public class LoggingStatement implements Statement {
|
||||
|
||||
private final Statement statement;
|
||||
|
||||
protected final String statementID;
|
||||
|
||||
protected final Logger logger;
|
||||
|
||||
protected static Logger.Level level = Logger.Level.TRACE;
|
||||
|
||||
public LoggingStatement(Statement statement, Logger logger) {
|
||||
this.statement = statement;
|
||||
this.logger = logger;
|
||||
this.statementID = LoggingUtil.getID(statement);
|
||||
}
|
||||
|
||||
public Statement getStatement() {
|
||||
return statement;
|
||||
}
|
||||
|
||||
public String getStatementID() {
|
||||
return statementID;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ResultSet executeQuery(String sql) throws SQLException {
|
||||
LoggingResultSet rs = new LoggingResultSet(statement.executeQuery(sql), logger);
|
||||
logger.logf(level, "%s.executeQuery(%s) = %s", statementID, sql, rs.getResultSetID());
|
||||
return rs;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int executeUpdate(String sql) throws SQLException {
|
||||
int i = statement.executeUpdate(sql);
|
||||
logger.logf(level, "%s.executeUpdate(%s) = %s", statementID, sql, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() throws SQLException {
|
||||
logger.logf(level, "%s.close()", statementID);
|
||||
statement.close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxFieldSize() throws SQLException {
|
||||
int i = statement.getMaxFieldSize();
|
||||
logger.logf(level, "%s.getMaxFieldSize() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setMaxFieldSize(int max) throws SQLException {
|
||||
logger.logf(level, "%s.setMaxFieldSize(%d)", statementID, max);
|
||||
statement.setMaxFieldSize(max);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxRows() throws SQLException {
|
||||
int i = statement.getMaxRows();
|
||||
logger.logf(level, "%s.getMaxRows() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setMaxRows(int max) throws SQLException {
|
||||
logger.logf(level, "%s.setMaxRows()", statementID);
|
||||
statement.setMaxRows(max);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setEscapeProcessing(boolean enable) throws SQLException {
|
||||
logger.logf(level, "%s.setEscapeProcessing(%s)", statementID, enable);
|
||||
statement.setEscapeProcessing(enable);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getQueryTimeout() throws SQLException {
|
||||
int i = statement.getQueryTimeout();
|
||||
logger.logf(level, "%s.getQueryTimeout() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setQueryTimeout(int seconds) throws SQLException {
|
||||
logger.logf(level, "%s.setQueryTimeout(%d)", statementID, seconds);
|
||||
statement.setQueryTimeout(seconds);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void cancel() throws SQLException {
|
||||
logger.logf(level, "%s.cancel()", statementID);
|
||||
statement.cancel();
|
||||
}
|
||||
|
||||
@Override
|
||||
public SQLWarning getWarnings() throws SQLException {
|
||||
logger.logf(level, "%s.getWarnings()", statementID);
|
||||
return statement.getWarnings();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearWarnings() throws SQLException {
|
||||
logger.logf(level, "%s.clearWarnings()", statementID);
|
||||
statement.clearWarnings();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCursorName(String name) throws SQLException {
|
||||
logger.logf(level, "%s.setCursorName(%s)", statementID, name);
|
||||
statement.setCursorName(name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(String sql) throws SQLException {
|
||||
boolean b = statement.execute(sql);
|
||||
logger.logf(level, "%s.execute(%s) = %s", statementID, sql, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ResultSet getResultSet() throws SQLException {
|
||||
LoggingResultSet rs = new LoggingResultSet(statement.getResultSet(), logger);
|
||||
logger.logf(level, "%s.executeQuery() = %s", statementID, rs.getResultSetID());
|
||||
return rs;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getUpdateCount() throws SQLException {
|
||||
int i = statement.getUpdateCount();
|
||||
logger.logf(level, "%s.getUpdateCount() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getMoreResults() throws SQLException {
|
||||
boolean b = statement.getMoreResults();
|
||||
logger.logf(level, "%s.getMoreResults() = %s", statementID, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFetchDirection(int direction) throws SQLException {
|
||||
logger.logf(level, "%s.setFetchDirection()", statementID);
|
||||
statement.setFetchDirection(direction);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getFetchDirection() throws SQLException {
|
||||
int i = statement.getFetchDirection();
|
||||
logger.logf(level, "%s.getFetchDirection() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFetchSize(int rows) throws SQLException {
|
||||
logger.logf(level, "%s.setFetchSize(%d)", statementID, rows);
|
||||
statement.setFetchSize(rows);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getFetchSize() throws SQLException {
|
||||
int i = statement.getFetchSize();
|
||||
logger.logf(level, "%s.getFetchSize() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getResultSetConcurrency() throws SQLException {
|
||||
int i = statement.getResultSetConcurrency();
|
||||
logger.logf(level, "%s.getResultSetConcurrency() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getResultSetType() throws SQLException {
|
||||
int i = statement.getResultSetType();
|
||||
logger.logf(level, "%s.getResultSetType() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addBatch(String sql) throws SQLException {
|
||||
logger.logf(level, "%s.addBatch(%d, %s)", statementID);
|
||||
statement.addBatch(sql);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearBatch() throws SQLException {
|
||||
logger.logf(level, "%s.clearBatch()", statementID);
|
||||
statement.clearBatch();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int[] executeBatch() throws SQLException {
|
||||
int[] i = statement.executeBatch();
|
||||
logger.logf(level, "%s.executeBatch() = %s", statementID, Arrays.toString(i));
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Connection getConnection() throws SQLException {
|
||||
LoggingConnection connection = new LoggingConnection(statement.getConnection(), logger);
|
||||
logger.logf(level, "%s.getConnection() = %s", statementID, connection.getConnectionID());
|
||||
return connection;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getMoreResults(int current) throws SQLException {
|
||||
boolean b = statement.getMoreResults(current);
|
||||
logger.logf(level, "%s.getMoreResults(%s) = %s", statementID, current, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ResultSet getGeneratedKeys() throws SQLException {
|
||||
LoggingResultSet rs = new LoggingResultSet(statement.getGeneratedKeys(), logger);
|
||||
logger.logf(level, "%s.getGeneratedKeys() = %s", statementID, rs.getResultSetID());
|
||||
return rs;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
|
||||
int i = statement.executeUpdate(sql, autoGeneratedKeys);
|
||||
logger.logf(level, "%s.executeUpdate(%s, %d) = %s", statementID, sql, autoGeneratedKeys, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
|
||||
int i = statement.executeUpdate(sql, columnIndexes);
|
||||
logger.logf(level, "%s.executeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnIndexes), i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int executeUpdate(String sql, String[] columnNames) throws SQLException {
|
||||
int i = statement.executeUpdate(sql, columnNames);
|
||||
logger.logf(level, "%s.executeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnNames), i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
|
||||
boolean b = statement.execute(sql, autoGeneratedKeys);
|
||||
logger.logf(level, "%s.execute(%s, %s) = %s", statementID, sql, autoGeneratedKeys, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(String sql, int[] columnIndexes) throws SQLException {
|
||||
boolean b = statement.execute(sql, columnIndexes);
|
||||
logger.logf(level, "%s.execute(%s, %s) = %s", statementID, sql, Arrays.toString(columnIndexes), b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(String sql, String[] columnNames) throws SQLException {
|
||||
boolean b = statement.execute(sql, columnNames);
|
||||
logger.logf(level, "%s.execute(%s, %s) = %s", statementID, sql, Arrays.toString(columnNames), b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getResultSetHoldability() throws SQLException {
|
||||
int i = statement.getResultSetHoldability();
|
||||
logger.logf(level, "%s.getResultSetHoldability() = %s", statementID, i);
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isClosed() throws SQLException {
|
||||
boolean b = statement.isClosed();
|
||||
logger.logf(level, "%s.isClosed() = %s", statementID, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPoolable(boolean poolable) throws SQLException {
|
||||
logger.logf(level, "%s.setPoolable(%s)", statementID, poolable);
|
||||
statement.setPoolable(poolable);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isPoolable() throws SQLException {
|
||||
boolean b = statement.isPoolable();
|
||||
logger.logf(level, "%s.isPoolable() = %s", statementID, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void closeOnCompletion() throws SQLException {
|
||||
logger.logf(level, "%s.closeOnCompletion()", statementID);
|
||||
statement.closeOnCompletion();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isCloseOnCompletion() throws SQLException {
|
||||
boolean b = statement.isCloseOnCompletion();
|
||||
logger.logf(level, "%s.isCloseOnCompletion() = %s", statementID, b);
|
||||
return b;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getLargeUpdateCount() throws SQLException {
|
||||
long x = statement.getLargeUpdateCount();
|
||||
logger.logf(level, "%s.getLargeUpdateCount() = %s", statementID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLargeMaxRows(long max) throws SQLException {
|
||||
logger.logf(level, "%s.setLargeMaxRows(%d)", statementID, max);
|
||||
statement.setLargeMaxRows(max);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getLargeMaxRows() throws SQLException {
|
||||
long x = statement.getLargeMaxRows();
|
||||
logger.logf(level, "%s.getLargeMaxRows() = %s", statementID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long[] executeLargeBatch() throws SQLException {
|
||||
long[] x = statement.executeLargeBatch();
|
||||
logger.logf(level, "%s.executeLargeBatch() = %s", statementID, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long executeLargeUpdate(String sql) throws SQLException {
|
||||
long x = statement.executeLargeUpdate(sql);
|
||||
logger.logf(level, "%s.executeLargeUpdate(%s) = %s", statementID, sql, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long executeLargeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
|
||||
long x = statement.executeLargeUpdate(sql, autoGeneratedKeys);
|
||||
logger.logf(level, "%s.executeLargeUpdate() = %s", statementID, sql, autoGeneratedKeys, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long executeLargeUpdate(String sql, int[] columnIndexes) throws SQLException {
|
||||
long x = statement.executeLargeUpdate(sql, columnIndexes);
|
||||
logger.logf(level, "%s.executeLargeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnIndexes), x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long executeLargeUpdate(String sql, String[] columnNames) throws SQLException {
|
||||
long x = statement.executeLargeUpdate(sql, columnNames);
|
||||
logger.logf(level, "%s.executeLargeUpdate(%s, %s) = %s", statementID, sql, Arrays.toString(columnNames), x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> T unwrap(Class<T> iface) throws SQLException {
|
||||
T x = statement.unwrap(iface);
|
||||
logger.logf(level, "%s.unwrap(%s) = %s", statementID, iface, x);
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
||||
boolean b = statement.isWrapperFor(iface);
|
||||
logger.logf(level, "%s.isWrapperFor(%s) = %s", statementID, iface, b);
|
||||
return b;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package org.apache.activemq.artemis.jdbc.store.logging;
|
||||
|
||||
public class LoggingUtil {
|
||||
public static String getID(Object object) {
|
||||
return new StringBuilder().append(object.getClass().getName()).append("@").append(Integer.toHexString(System.identityHashCode(object))).toString();
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue