Created
March 31, 2018 09:46
-
-
Save japgolly/cb50c4773ce37ddaa190222bd008dbca to your computer and use it in GitHub Desktop.
SqlTracer export example
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import java.io.{Closeable, InputStream, PrintWriter, Reader} | |
import java.net.URL | |
import java.sql.{Blob, CallableStatement, Clob, Connection, DatabaseMetaData, Date, NClob, ParameterMetaData, PreparedStatement, Ref, ResultSet, ResultSetMetaData, RowId, SQLWarning, SQLXML, Savepoint, Statement, Struct, Time, Timestamp} | |
import java.util.{Calendar, Properties} | |
import java.{sql, util} | |
import java.util.concurrent.Executor | |
import java.util.logging.Logger | |
import javax.sql.DataSource | |
trait SqlTracer { | |
final def apply(ds: DataSource): DataSource = | |
new SqlTracer.DataSourceProxy(ds)(this) | |
def executePreparedStatement[@specialized(Boolean, Int, Long) A](method : String, | |
sql : String, | |
batches: Int, | |
run : () => A): A | |
} | |
object SqlTracer { | |
final class DataSourceProxy(underlying: DataSource)(implicit tracer: SqlTracer) extends DataSource with Closeable { | |
def proxyC(c: Connection) = new ConnectionProxy(c) | |
override def getConnection: Connection = | |
proxyC( | |
underlying.getConnection) | |
override def getConnection(username: String, password: String): Connection = | |
proxyC( | |
underlying.getConnection(username, password)) | |
override def close(): Unit = | |
underlying match { | |
case c: Closeable => c.close() | |
case _ => () | |
} | |
override def setLoginTimeout(seconds: Int): Unit = | |
underlying.setLoginTimeout(seconds) | |
override def setLogWriter(out: PrintWriter): Unit = | |
underlying.setLogWriter(out) | |
override def getParentLogger: Logger = | |
underlying.getParentLogger | |
override def getLoginTimeout: Int = | |
underlying.getLoginTimeout | |
override def getLogWriter: PrintWriter = | |
underlying.getLogWriter | |
override def unwrap[T](iface: Class[T]): T = | |
underlying.unwrap(iface) | |
override def isWrapperFor(iface: Class[_]): Boolean = | |
underlying.isWrapperFor(iface) | |
} | |
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ | |
final class ConnectionProxy(underlying: Connection)(implicit tracer: SqlTracer) extends Connection { | |
def proxyPS(sql: String, ps: PreparedStatement) = new PreparedStatementProxy(sql, ps) | |
override def abort(executor: Executor): Unit = | |
underlying.abort(executor) | |
override def clearWarnings(): Unit = | |
underlying.clearWarnings() | |
override def close(): Unit = | |
underlying.close() | |
override def commit(): Unit = | |
underlying.commit() | |
override def createArrayOf(typeName: String, elements: Array[AnyRef]): sql.Array = | |
underlying.createArrayOf(typeName, elements) | |
override def createBlob(): Blob = | |
underlying.createBlob() | |
override def createClob(): Clob = | |
underlying.createClob() | |
override def createNClob(): NClob = | |
underlying.createNClob() | |
override def createSQLXML(): SQLXML = | |
underlying.createSQLXML() | |
override def createStatement(): Statement = | |
underlying.createStatement() | |
override def createStatement(resultSetType: Int, resultSetConcurrency: Int, resultSetHoldability: Int): Statement = | |
underlying.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability) | |
override def createStatement(resultSetType: Int, resultSetConcurrency: Int): Statement = | |
underlying.createStatement(resultSetType, resultSetConcurrency) | |
override def createStruct(typeName: String, attributes: Array[AnyRef]): Struct = | |
underlying.createStruct(typeName, attributes) | |
override def getAutoCommit: Boolean = | |
underlying.getAutoCommit | |
override def getCatalog: String = | |
underlying.getCatalog | |
override def getClientInfo: Properties = | |
underlying.getClientInfo | |
override def getClientInfo(name: String): String = | |
underlying.getClientInfo(name) | |
override def getHoldability: Int = | |
underlying.getHoldability | |
override def getMetaData: DatabaseMetaData = | |
underlying.getMetaData | |
override def getNetworkTimeout: Int = | |
underlying.getNetworkTimeout | |
override def getSchema: String = | |
underlying.getSchema | |
override def getTransactionIsolation: Int = | |
underlying.getTransactionIsolation | |
override def getTypeMap: util.Map[String, Class[_]] = | |
underlying.getTypeMap | |
override def getWarnings: SQLWarning = | |
underlying.getWarnings | |
override def isClosed: Boolean = | |
underlying.isClosed | |
override def isReadOnly: Boolean = | |
underlying.isReadOnly | |
override def isValid(timeout: Int): Boolean = | |
underlying.isValid(timeout) | |
override def isWrapperFor(iface: Class[_]): Boolean = | |
underlying.isWrapperFor(iface) | |
override def nativeSQL(sql: String): String = | |
underlying.nativeSQL(sql) | |
override def prepareCall(sql: String, resultSetType: Int, resultSetConcurrency: Int, resultSetHoldability: Int): CallableStatement = | |
underlying.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability) | |
override def prepareCall(sql: String, resultSetType: Int, resultSetConcurrency: Int): CallableStatement = | |
underlying.prepareCall(sql, resultSetType, resultSetConcurrency) | |
override def prepareCall(sql: String): CallableStatement = | |
underlying.prepareCall(sql) | |
override def prepareStatement(sql: String, autoGeneratedKeys: Int): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, autoGeneratedKeys)) | |
override def prepareStatement(sql: String, columnIndexes: Array[Int]): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, columnIndexes)) | |
override def prepareStatement(sql: String, columnNames: Array[String]): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, columnNames)) | |
override def prepareStatement(sql: String, resultSetType: Int, resultSetConcurrency: Int, resultSetHoldability: Int): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability)) | |
override def prepareStatement(sql: String, resultSetType: Int, resultSetConcurrency: Int): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, resultSetType, resultSetConcurrency)) | |
override def prepareStatement(sql: String): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql)) | |
override def releaseSavepoint(savepoint: Savepoint): Unit = | |
underlying.releaseSavepoint(savepoint) | |
override def rollback(): Unit = | |
underlying.rollback() | |
override def rollback(savepoint: Savepoint): Unit = | |
underlying.rollback(savepoint) | |
override def setAutoCommit(autoCommit: Boolean): Unit = | |
underlying.setAutoCommit(autoCommit) | |
override def setCatalog(catalog: String): Unit = | |
underlying.setCatalog(catalog) | |
override def setClientInfo(name: String, value: String): Unit = | |
underlying.setClientInfo(name, value) | |
override def setClientInfo(properties: Properties): Unit = | |
underlying.setClientInfo(properties) | |
override def setHoldability(holdability: Int): Unit = | |
underlying.setHoldability(holdability) | |
override def setNetworkTimeout(executor: Executor, milliseconds: Int): Unit = | |
underlying.setNetworkTimeout(executor, milliseconds) | |
override def setReadOnly(readOnly: Boolean): Unit = | |
underlying.setReadOnly(readOnly) | |
override def setSavepoint(): Savepoint = | |
underlying.setSavepoint() | |
override def setSavepoint(name: String): Savepoint = | |
underlying.setSavepoint(name) | |
override def setSchema(schema: String): Unit = | |
underlying.setSchema(schema) | |
override def setTransactionIsolation(level: Int): Unit = | |
underlying.setTransactionIsolation(level) | |
override def setTypeMap(map: util.Map[String, Class[_]]): Unit = | |
underlying.setTypeMap(map) | |
override def unwrap[T](iface: Class[T]): T = | |
underlying.unwrap[T](iface) | |
} | |
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ | |
final class PreparedStatementProxy(preparedSql: String, underlying: PreparedStatement)(implicit tracer: SqlTracer) extends PreparedStatement { | |
var batchSize = 0 | |
override def addBatch(): Unit = { | |
batchSize += 1 | |
underlying.addBatch() | |
} | |
override def addBatch(sql: String): Unit = | |
underlying.addBatch(sql: String) // Spec declares this a runtime exception | |
override def cancel(): Unit = | |
underlying.cancel() | |
override def clearBatch(): Unit = | |
underlying.clearBatch() | |
override def clearParameters(): Unit = | |
underlying.clearParameters() | |
override def clearWarnings(): Unit = | |
underlying.clearWarnings() | |
override def close(): Unit = | |
underlying.close() | |
override def closeOnCompletion(): Unit = | |
underlying.closeOnCompletion() | |
override def execute(): Boolean = | |
tracer.executePreparedStatement("execute", preparedSql, 1, () => | |
underlying.execute()) | |
override def execute(sql: String, autoGeneratedKeys: Int): Boolean = | |
underlying.execute(sql: String, autoGeneratedKeys: Int) // Spec declares this a runtime exception | |
override def execute(sql: String, columnIndexes: Array[Int]): Boolean = | |
underlying.execute(sql: String, columnIndexes: Array[Int]) // Spec declares this a runtime exception | |
override def execute(sql: String, columnNames: Array[String]): Boolean = | |
underlying.execute(sql: String, columnNames: Array[String]) // Spec declares this a runtime exception | |
override def execute(sql: String): Boolean = | |
underlying.execute(sql: String) // Spec declares this a runtime exception | |
override def executeBatch(): Array[Int] = | |
tracer.executePreparedStatement("executeBatch", preparedSql, batchSize, () => | |
underlying.executeBatch()) | |
override def executeLargeBatch(): Array[Long] = | |
tracer.executePreparedStatement("executeLargeBatch", preparedSql, batchSize, () => | |
underlying.executeLargeBatch()) | |
override def executeLargeUpdate(): Long = | |
tracer.executePreparedStatement("executeLargeUpdate", preparedSql, 1, () => | |
underlying.executeLargeUpdate()) | |
override def executeQuery(): ResultSet = | |
tracer.executePreparedStatement("executeQuery", preparedSql, 1, () => | |
underlying.executeQuery()) | |
override def executeQuery(sql: String): ResultSet = | |
underlying.executeQuery(sql) // Spec declares this a runtime exception | |
override def executeUpdate(): Int = | |
tracer.executePreparedStatement("executeUpdate", preparedSql, 1, () => | |
underlying.executeUpdate()) | |
override def executeUpdate(sql: String, autoGeneratedKeys: Int): Int = | |
underlying.executeUpdate(sql: String, autoGeneratedKeys: Int) // Spec declares this a runtime exception | |
override def executeUpdate(sql: String, columnIndexes: Array[Int]): Int = | |
underlying.executeUpdate(sql: String, columnIndexes: Array[Int]) // Spec declares this a runtime exception | |
override def executeUpdate(sql: String, columnNames: Array[String]): Int = | |
underlying.executeUpdate(sql: String, columnNames: Array[String]) // Spec declares this a runtime exception | |
override def executeUpdate(sql: String): Int = | |
underlying.executeUpdate(sql: String) // Spec declares this a runtime exception | |
override def getConnection: Connection = | |
underlying.getConnection | |
override def getFetchDirection: Int = | |
underlying.getFetchDirection | |
override def getFetchSize: Int = | |
underlying.getFetchSize | |
override def getGeneratedKeys: ResultSet = | |
underlying.getGeneratedKeys | |
override def getMaxFieldSize: Int = | |
underlying.getMaxFieldSize | |
override def getMaxRows: Int = | |
underlying.getMaxRows | |
override def getMetaData: ResultSetMetaData = | |
underlying.getMetaData | |
override def getMoreResults: Boolean = | |
underlying.getMoreResults | |
override def getMoreResults(current: Int): Boolean = | |
underlying.getMoreResults(current: Int) | |
override def getParameterMetaData: ParameterMetaData = | |
underlying.getParameterMetaData | |
override def getQueryTimeout: Int = | |
underlying.getQueryTimeout | |
override def getResultSet: ResultSet = | |
underlying.getResultSet | |
override def getResultSetConcurrency: Int = | |
underlying.getResultSetConcurrency | |
override def getResultSetHoldability: Int = | |
underlying.getResultSetHoldability | |
override def getResultSetType: Int = | |
underlying.getResultSetType | |
override def getUpdateCount: Int = | |
underlying.getUpdateCount | |
override def getWarnings: SQLWarning = | |
underlying.getWarnings | |
override def isClosed: Boolean = | |
underlying.isClosed | |
override def isCloseOnCompletion: Boolean = | |
underlying.isCloseOnCompletion | |
override def isPoolable: Boolean = | |
underlying.isPoolable | |
override def isWrapperFor(iface: Class[_]): Boolean = | |
underlying.isWrapperFor(iface: Class[_]) | |
override def setArray(parameterIndex: Int, x: sql.Array): Unit = | |
underlying.setArray(parameterIndex: Int, x: sql.Array) | |
override def setAsciiStream(parameterIndex: Int, x: InputStream, length: Int): Unit = | |
underlying.setAsciiStream(parameterIndex: Int, x: InputStream, length: Int) | |
override def setAsciiStream(parameterIndex: Int, x: InputStream, length: Long): Unit = | |
underlying.setAsciiStream(parameterIndex: Int, x: InputStream, length: Long) | |
override def setAsciiStream(parameterIndex: Int, x: InputStream): Unit = | |
underlying.setAsciiStream(parameterIndex: Int, x: InputStream) | |
override def setBigDecimal(parameterIndex: Int, x: java.math.BigDecimal): Unit = | |
underlying.setBigDecimal(parameterIndex: Int, x: java.math.BigDecimal) | |
override def setBinaryStream(parameterIndex: Int, x: InputStream, length: Int): Unit = | |
underlying.setBinaryStream(parameterIndex: Int, x: InputStream, length: Int) | |
override def setBinaryStream(parameterIndex: Int, x: InputStream, length: Long): Unit = | |
underlying.setBinaryStream(parameterIndex: Int, x: InputStream, length: Long) | |
override def setBinaryStream(parameterIndex: Int, x: InputStream): Unit = | |
underlying.setBinaryStream(parameterIndex: Int, x: InputStream) | |
override def setBlob(parameterIndex: Int, inputStream: InputStream, length: Long): Unit = | |
underlying.setBlob(parameterIndex: Int, inputStream: InputStream, length: Long) | |
override def setBlob(parameterIndex: Int, inputStream: InputStream): Unit = | |
underlying.setBlob(parameterIndex: Int, inputStream: InputStream) | |
override def setBlob(parameterIndex: Int, x: Blob): Unit = | |
underlying.setBlob(parameterIndex: Int, x: Blob) | |
override def setBoolean(parameterIndex: Int, x: Boolean): Unit = | |
underlying.setBoolean(parameterIndex: Int, x: Boolean) | |
override def setByte(parameterIndex: Int, x: Byte): Unit = | |
underlying.setByte(parameterIndex: Int, x: Byte) | |
override def setBytes(parameterIndex: Int, x: Array[Byte]): Unit = | |
underlying.setBytes(parameterIndex: Int, x: Array[Byte]) | |
override def setCharacterStream(parameterIndex: Int, reader: Reader, length: Int): Unit = | |
underlying.setCharacterStream(parameterIndex: Int, reader: Reader, length: Int) | |
override def setCharacterStream(parameterIndex: Int, reader: Reader, length: Long): Unit = | |
underlying.setCharacterStream(parameterIndex: Int, reader: Reader, length: Long) | |
override def setCharacterStream(parameterIndex: Int, reader: Reader): Unit = | |
underlying.setCharacterStream(parameterIndex: Int, reader: Reader) | |
override def setClob(parameterIndex: Int, reader: Reader, length: Long): Unit = | |
underlying.setClob(parameterIndex: Int, reader: Reader, length: Long) | |
override def setClob(parameterIndex: Int, reader: Reader): Unit = | |
underlying.setClob(parameterIndex: Int, reader: Reader) | |
override def setClob(parameterIndex: Int, x: Clob): Unit = | |
underlying.setClob(parameterIndex: Int, x: Clob) | |
override def setCursorName(name: String): Unit = | |
underlying.setCursorName(name: String) | |
override def setDate(parameterIndex: Int, x: Date, cal: Calendar): Unit = | |
underlying.setDate(parameterIndex: Int, x: Date, cal: Calendar) | |
override def setDate(parameterIndex: Int, x: Date): Unit = | |
underlying.setDate(parameterIndex: Int, x: Date) | |
override def setDouble(parameterIndex: Int, x: Double): Unit = | |
underlying.setDouble(parameterIndex: Int, x: Double) | |
override def setEscapeProcessing(enable: Boolean): Unit = | |
underlying.setEscapeProcessing(enable: Boolean) | |
override def setFetchDirection(direction: Int): Unit = | |
underlying.setFetchDirection(direction: Int) | |
override def setFetchSize(rows: Int): Unit = | |
underlying.setFetchSize(rows: Int) | |
override def setFloat(parameterIndex: Int, x: Float): Unit = | |
underlying.setFloat(parameterIndex: Int, x: Float) | |
override def setInt(parameterIndex: Int, x: Int): Unit = | |
underlying.setInt(parameterIndex: Int, x: Int) | |
override def setLong(parameterIndex: Int, x: Long): Unit = | |
underlying.setLong(parameterIndex: Int, x: Long) | |
override def setMaxFieldSize(max: Int): Unit = | |
underlying.setMaxFieldSize(max: Int) | |
override def setMaxRows(max: Int): Unit = | |
underlying.setMaxRows(max: Int) | |
override def setNCharacterStream(parameterIndex: Int, value: Reader, length: Long): Unit = | |
underlying.setNCharacterStream(parameterIndex: Int, value: Reader, length: Long) | |
override def setNCharacterStream(parameterIndex: Int, value: Reader): Unit = | |
underlying.setNCharacterStream(parameterIndex: Int, value: Reader) | |
override def setNClob(parameterIndex: Int, reader: Reader, length: Long): Unit = | |
underlying.setNClob(parameterIndex: Int, reader: Reader, length: Long) | |
override def setNClob(parameterIndex: Int, reader: Reader): Unit = | |
underlying.setNClob(parameterIndex: Int, reader: Reader) | |
override def setNClob(parameterIndex: Int, value: NClob): Unit = | |
underlying.setNClob(parameterIndex: Int, value: NClob) | |
override def setNString(parameterIndex: Int, value: String): Unit = | |
underlying.setNString(parameterIndex: Int, value: String) | |
override def setNull(parameterIndex: Int, sqlType: Int, typeName: String): Unit = | |
underlying.setNull(parameterIndex: Int, sqlType: Int, typeName: String) | |
override def setNull(parameterIndex: Int, sqlType: Int): Unit = | |
underlying.setNull(parameterIndex: Int, sqlType: Int) | |
override def setObject(parameterIndex: Int, x: Any, targetSqlType: Int, scaleOrLength: Int): Unit = | |
underlying.setObject(parameterIndex: Int, x: Any, targetSqlType: Int, scaleOrLength: Int) | |
override def setObject(parameterIndex: Int, x: Any, targetSqlType: Int): Unit = | |
underlying.setObject(parameterIndex: Int, x: Any, targetSqlType: Int) | |
override def setObject(parameterIndex: Int, x: Any): Unit = | |
underlying.setObject(parameterIndex: Int, x: Any) | |
override def setPoolable(poolable: Boolean): Unit = | |
underlying.setPoolable(poolable: Boolean) | |
override def setQueryTimeout(seconds: Int): Unit = | |
underlying.setQueryTimeout(seconds: Int) | |
override def setRef(parameterIndex: Int, x: Ref): Unit = | |
underlying.setRef(parameterIndex: Int, x: Ref) | |
override def setRowId(parameterIndex: Int, x: RowId): Unit = | |
underlying.setRowId(parameterIndex: Int, x: RowId) | |
override def setShort(parameterIndex: Int, x: Short): Unit = | |
underlying.setShort(parameterIndex: Int, x: Short) | |
override def setSQLXML(parameterIndex: Int, xmlObject: SQLXML): Unit = | |
underlying.setSQLXML(parameterIndex: Int, xmlObject: SQLXML) | |
override def setString(parameterIndex: Int, x: String): Unit = | |
underlying.setString(parameterIndex: Int, x: String) | |
override def setTime(parameterIndex: Int, x: Time, cal: Calendar): Unit = | |
underlying.setTime(parameterIndex: Int, x: Time, cal: Calendar) | |
override def setTime(parameterIndex: Int, x: Time): Unit = | |
underlying.setTime(parameterIndex: Int, x: Time) | |
override def setTimestamp(parameterIndex: Int, x: Timestamp, cal: Calendar): Unit = | |
underlying.setTimestamp(parameterIndex: Int, x: Timestamp, cal: Calendar) | |
override def setTimestamp(parameterIndex: Int, x: Timestamp): Unit = | |
underlying.setTimestamp(parameterIndex: Int, x: Timestamp) | |
@deprecated("", "") | |
override def setUnicodeStream(parameterIndex: Int, x: InputStream, length: Int): Unit = | |
underlying.setUnicodeStream(parameterIndex: Int, x: InputStream, length: Int) | |
override def setURL(parameterIndex: Int, x: URL): Unit = | |
underlying.setURL(parameterIndex: Int, x: URL) | |
override def unwrap[T](iface: Class[T]): T = | |
underlying.unwrap[T](iface: Class[T]) | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import java.io.Closeable | |
import java.sql.{Connection, PreparedStatement, ResultSet} | |
import javax.sql.DataSource | |
trait SqlTracer { | |
final def apply(ds: DataSource): DataSource = | |
new SqlTracer.DataSourceProxy(ds)(this) | |
def executePreparedStatement[@specialized(Boolean, Int, Long) A](method : String, | |
sql : String, | |
batches: Int, | |
run : () => A): A | |
} | |
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | |
object SqlTracer { | |
final class DataSourceProxy(underlying: DataSource)(implicit tracer: SqlTracer) extends DataSource with Closeable { | |
def proxyC(c: Connection) = new ConnectionProxy(c) | |
export underlying.{getConnection => _, close => _, _} | |
override def getConnection: Connection = | |
proxyC( | |
underlying.getConnection) | |
override def getConnection(username: String, password: String): Connection = | |
proxyC( | |
underlying.getConnection(username, password)) | |
override def close(): Unit = | |
underlying match { | |
case c: Closeable => c.close() | |
case _ => () | |
} | |
} | |
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ | |
final class ConnectionProxy(underlying: Connection)(implicit tracer: SqlTracer) extends Connection { | |
def proxyPS(sql: String, ps: PreparedStatement) = new PreparedStatementProxy(sql, ps) | |
export underlying.{prepareStatement => _, _} | |
override def prepareStatement(sql: String, autoGeneratedKeys: Int): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, autoGeneratedKeys)) | |
override def prepareStatement(sql: String, columnIndexes: Array[Int]): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, columnIndexes)) | |
override def prepareStatement(sql: String, columnNames: Array[String]): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, columnNames)) | |
override def prepareStatement(sql: String, resultSetType: Int, resultSetConcurrency: Int, resultSetHoldability: Int): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability)) | |
override def prepareStatement(sql: String, resultSetType: Int, resultSetConcurrency: Int): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql, resultSetType, resultSetConcurrency)) | |
override def prepareStatement(sql: String): PreparedStatement = | |
proxyPS(sql, | |
underlying.prepareStatement(sql)) | |
} | |
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ | |
final class PreparedStatementProxy(preparedSql: String, underlying: PreparedStatement)(implicit tracer: SqlTracer) extends PreparedStatement { | |
var batchSize = 0 | |
export underlying.{ | |
addBatch => _, | |
execute => _, | |
executeBatch => _, | |
executeLargeBatch => _, | |
executeLargeUpdate => _, | |
executeQuery => _, | |
executeUpdate => _, | |
_} | |
override def addBatch(): Unit = { | |
batchSize += 1 | |
underlying.addBatch() | |
} | |
override def addBatch(sql: String): Unit = | |
underlying.addBatch(sql: String) // Spec declares this a runtime exception | |
override def execute(): Boolean = | |
tracer.executePreparedStatement("execute", preparedSql, 1, () => | |
underlying.execute()) | |
override def execute(sql: String, autoGeneratedKeys: Int): Boolean = | |
underlying.execute(sql: String, autoGeneratedKeys: Int) // Spec declares this a runtime exception | |
override def execute(sql: String, columnIndexes: Array[Int]): Boolean = | |
underlying.execute(sql: String, columnIndexes: Array[Int]) // Spec declares this a runtime exception | |
override def execute(sql: String, columnNames: Array[String]): Boolean = | |
underlying.execute(sql: String, columnNames: Array[String]) // Spec declares this a runtime exception | |
override def execute(sql: String): Boolean = | |
underlying.execute(sql: String) // Spec declares this a runtime exception | |
override def executeBatch(): Array[Int] = | |
tracer.executePreparedStatement("executeBatch", preparedSql, batchSize, () => | |
underlying.executeBatch()) | |
override def executeLargeBatch(): Array[Long] = | |
tracer.executePreparedStatement("executeLargeBatch", preparedSql, batchSize, () => | |
underlying.executeLargeBatch()) | |
override def executeLargeUpdate(): Long = | |
tracer.executePreparedStatement("executeLargeUpdate", preparedSql, 1, () => | |
underlying.executeLargeUpdate()) | |
override def executeQuery(): ResultSet = | |
tracer.executePreparedStatement("executeQuery", preparedSql, 1, () => | |
underlying.executeQuery()) | |
override def executeQuery(sql: String): ResultSet = | |
underlying.executeQuery(sql) // Spec declares this a runtime exception | |
override def executeUpdate(): Int = | |
tracer.executePreparedStatement("executeUpdate", preparedSql, 1, () => | |
underlying.executeUpdate()) | |
override def executeUpdate(sql: String, autoGeneratedKeys: Int): Int = | |
underlying.executeUpdate(sql: String, autoGeneratedKeys: Int) // Spec declares this a runtime exception | |
override def executeUpdate(sql: String, columnIndexes: Array[Int]): Int = | |
underlying.executeUpdate(sql: String, columnIndexes: Array[Int]) // Spec declares this a runtime exception | |
override def executeUpdate(sql: String, columnNames: Array[String]): Int = | |
underlying.executeUpdate(sql: String, columnNames: Array[String]) // Spec declares this a runtime exception | |
override def executeUpdate(sql: String): Int = | |
underlying.executeUpdate(sql: String) // Spec declares this a runtime exception | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment