added statement timeout

sylvainlaurent · sylvainlaurent · commit 9ebb7a71d671 · 2014-02-05T23:26:09.000+01:00
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/driver/LoggingPreparedStatementInvocationHandler.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/driver/LoggingPreparedStatementInvocationHandler.java
@@ -92,7 +92,7 @@ public Object invoke(@Nullable final Object proxy, @Nullable final Method _metho
     protected ResultSet internalExecutePreparedQuery(final Method method) throws Throwable {
         final UUID logId = UUID.randomUUID();
         PerfLogger.logBeforePreparedStatement(connectionId, logId, rawSql, paramValues,
-                StatementType.PREPARED_QUERY_STMT, databaseType);
+                StatementType.PREPARED_QUERY_STMT, databaseType, wrappedStatement.getQueryTimeout());
         final long start = System.nanoTime();
         Throwable exc = null;
         try {
@@ -116,7 +116,7 @@ protected Object internalExecutePrepared(final Method method, @Nullable final Ob
         final UUID logId = UUID.randomUUID();
         final long start = System.nanoTime();
         PerfLogger.logBeforePreparedStatement(connectionId, logId, rawSql, paramValues,
-                StatementType.BASE_PREPARED_STMT, databaseType);
+                StatementType.BASE_PREPARED_STMT, databaseType, wrappedStatement.getQueryTimeout());
         Throwable exc = null;
         try {
             return Utils.invokeUnwrapException(wrappedStatement, method, args);
@@ -134,7 +134,7 @@ protected Object internalExecutePrepared(final Method method, @Nullable final Ob
     protected Object internalExecuteBatch(final Method method, @Nullable final Object[] args) throws Throwable {
         final UUID logId = UUID.randomUUID();
         PerfLogger.logPreparedBatchedStatements(connectionId, rawSql, batchedPreparedOrNonPreparedStmtExecutions,
-                databaseType);
+                databaseType, wrappedStatement.getQueryTimeout());
         final long start = System.nanoTime();
         Throwable exc = null;
         try {
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/driver/LoggingStatementInvocationHandler.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/driver/LoggingStatementInvocationHandler.java
@@ -81,7 +81,8 @@ public Object invoke(final @Nullable Object _proxy, @Nullable final Method _meth
     protected final ResultSet internalExecuteQuery(final Method method, final Object[] args) throws Throwable {
         final UUID logId = UUID.randomUUID();
         final long start = System.nanoTime();
-        PerfLogger.logBeforeStatement(connectionId, logId, (String) args[0], StatementType.NON_PREPARED_QUERY_STMT);
+        PerfLogger.logBeforeStatement(connectionId, logId, (String) args[0], StatementType.NON_PREPARED_QUERY_STMT,
+                wrappedStatement.getQueryTimeout());
         Throwable exc = null;
         try {
             final ResultSet resultSet = (ResultSet) Utils.invokeUnwrapExceptionReturnNonNull(wrappedStatement, method,
@@ -102,7 +103,8 @@ protected final ResultSet internalExecuteQuery(final Method method, final Object
     @Nullable
     protected final Object internalExecute(final Method method, final Object[] args) throws Throwable {
         final UUID logId = UUID.randomUUID();
-        PerfLogger.logBeforeStatement(connectionId, logId, (String) args[0], StatementType.BASE_NON_PREPARED_STMT);
+        PerfLogger.logBeforeStatement(connectionId, logId, (String) args[0], StatementType.BASE_NON_PREPARED_STMT,
+                wrappedStatement.getQueryTimeout());
         Throwable exc = null;
         final long start = System.nanoTime();
         try {
@@ -119,7 +121,8 @@ protected final Object internalExecute(final Method method, final Object[] args)
     @Nullable
     protected Object internalExecuteBatch(final Method method, @Nullable final Object[] args) throws Throwable {
         final UUID logId = UUID.randomUUID();
-        PerfLogger.logNonPreparedBatchedStatements(connectionId, logId, batchedNonPreparedStmtExecutions, databaseType);
+        PerfLogger.logNonPreparedBatchedStatements(connectionId, logId, batchedNonPreparedStmtExecutions, databaseType,
+                wrappedStatement.getQueryTimeout());
         Throwable exc = null;
         final long start = System.nanoTime();
         try {
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/logger/PerfLogger.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/logger/PerfLogger.java
@@ -73,18 +73,18 @@ public class PerfLogger {
     }
 
     public static void logBeforeStatement(final UUID connectionId, final UUID logId, final String sql,
-            final StatementType statementType) {
+            final StatementType statementType, final int timeout) {
         if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {
             LOGGER_ORIGINAL_SQL.debug("Before execution of non-prepared stmt {}: {}", logId, sql);
         }
         final long now = System.currentTimeMillis();
         PerfLoggerRemoting.postLog(new StatementLog(connectionId, logId, now, statementType, sql, Thread
-                .currentThread().getName()));
+                .currentThread().getName(), timeout));
     }
 
     public static void logBeforePreparedStatement(final UUID connectionId, final UUID logId, final String rawSql,
             final PreparedStatementValuesHolder pstmtValues, final StatementType statementType,
-            final DatabaseType databaseType) {
+            final DatabaseType databaseType, final int timeout) {
         if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {
             LOGGER_ORIGINAL_SQL.debug("Before execution of prepared stmt {}: {}", logId, rawSql);
         }
@@ -94,11 +94,11 @@ public static void logBeforePreparedStatement(final UUID connectionId, final UUI
         }
         final long now = System.currentTimeMillis();
         PerfLoggerRemoting.postLog(new StatementLog(connectionId, logId, now, statementType, rawSql, filledSql, Thread
-                .currentThread().getName()));
+                .currentThread().getName(), timeout));
     }
 
     public static void logNonPreparedBatchedStatements(final UUID connectionId, final UUID logId,
-            final List<String> batchedExecutions, final DatabaseType databaseType) {
+            final List<String> batchedExecutions, final DatabaseType databaseType, final int timeout) {
 
         final long now = System.currentTimeMillis();
         if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {
@@ -112,11 +112,11 @@ public static void logNonPreparedBatchedStatements(final UUID connectionId, fina
             }
         }
         PerfLoggerRemoting.postLog(new BatchedNonPreparedStatementsLog(connectionId, logId, now, batchedExecutions,
-                Thread.currentThread().getName()));
+                Thread.currentThread().getName(), timeout));
     }
 
     public static void logPreparedBatchedStatements(final UUID connectionId, final String rawSql,
-            final List<Object> batchedExecutions, final DatabaseType databaseType) {
+            final List<Object> batchedExecutions, final DatabaseType databaseType, final int timeout) {
         final long now = System.currentTimeMillis();
         if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {
             LOGGER_ORIGINAL_SQL.debug("Before execution of {} batched prepared statements with raw sql {}",
@@ -138,7 +138,7 @@ public static void logPreparedBatchedStatements(final UUID connectionId, final S
             }
         }
         PerfLoggerRemoting.postLog(new BatchedPreparedStatementsLog(connectionId, UUID.randomUUID(), now, rawSql,
-                filledSqlList, Thread.currentThread().getName()));
+                filledSqlList, Thread.currentThread().getName(), timeout));
     }
 
     public static void logStatementExecuted(final UUID logId, final long durationNanos,
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/AbstractBeforeStatementExecutionLog.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/AbstractBeforeStatementExecutionLog.java
@@ -28,14 +28,16 @@ public class AbstractBeforeStatementExecutionLog implements LogMessage {
     private final long timestamp;
     private final StatementType statementType;
     private final String threadName;
+    private final int timeout;
 
     public AbstractBeforeStatementExecutionLog(final UUID connectionId, final UUID logId, final long timestamp,
-            final StatementType statementType, final String threadName) {
+            final StatementType statementType, final String threadName, final int timeout) {
         connectionUuid = connectionId;
         this.logId = logId;
         this.timestamp = timestamp;
         this.statementType = statementType;
         this.threadName = threadName;
+        this.timeout = timeout;
     }
 
     public UUID getConnectionUuid() {
@@ -58,4 +60,8 @@ public String getThreadName() {
         return threadName;
     }
 
+    public int getTimeout() {
+        return timeout;
+    }
+
 }
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/BatchedNonPreparedStatementsLog.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/BatchedNonPreparedStatementsLog.java
@@ -29,8 +29,8 @@ public class BatchedNonPreparedStatementsLog extends AbstractBeforeStatementExec
     private final List<String> sqlList;
 
     public BatchedNonPreparedStatementsLog(final UUID connectionId, final UUID logId, final long timestamp,
-            final List<String> sqlList, final String threadName) {
-        super(connectionId, logId, timestamp, StatementType.NON_PREPARED_BATCH_EXECUTION, threadName);
+            final List<String> sqlList, final String threadName, final int timeout) {
+        super(connectionId, logId, timestamp, StatementType.NON_PREPARED_BATCH_EXECUTION, threadName, timeout);
         this.sqlList = Collections.unmodifiableList(new ArrayList<String>(sqlList));
     }
 
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/BatchedPreparedStatementsLog.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/BatchedPreparedStatementsLog.java
@@ -30,8 +30,8 @@ public class BatchedPreparedStatementsLog extends AbstractBeforeStatementExecuti
     private final List<String> sqlList;
 
     public BatchedPreparedStatementsLog(final UUID connectionId, final UUID logId, final long timestamp,
-            final String rawSql, final List<String> sqlList, final String threadName) {
-        super(connectionId, logId, timestamp, StatementType.PREPARED_BATCH_EXECUTION, threadName);
+            final String rawSql, final List<String> sqlList, final String threadName, final int timeout) {
+        super(connectionId, logId, timestamp, StatementType.PREPARED_BATCH_EXECUTION, threadName, timeout);
         this.rawSql = rawSql;
         this.sqlList = Collections.unmodifiableList(new ArrayList<String>(sqlList));
     }
diff --git a/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/StatementLog.java b/jdbc-perf-logger-driver/src/main/java/ch/sla/jdbcperflogger/model/StatementLog.java
@@ -28,16 +28,17 @@ public class StatementLog extends AbstractBeforeStatementExecutionLog {
     private final boolean preparedStatement;
 
     public StatementLog(final UUID connectionId, final UUID logId, final long timestamp,
-            final StatementType statementType, final String sql, final String threadName) {
-        super(connectionId, logId, timestamp, statementType, threadName);
+            final StatementType statementType, final String sql, final String threadName, final int timeout) {
+        super(connectionId, logId, timestamp, statementType, threadName, timeout);
         rawSql = sql;
         filledSql = sql;
         preparedStatement = false;
     }
 
     public StatementLog(final UUID connectionId, final UUID logId, final long timestamp,
-            final StatementType statementType, final String rawSql, final String filledSql, final String threadName) {
-        super(connectionId, logId, timestamp, statementType, threadName);
+            final StatementType statementType, final String rawSql, final String filledSql, final String threadName,
+            final int timeout) {
+        super(connectionId, logId, timestamp, statementType, threadName, timeout);
         this.rawSql = rawSql;
         this.filledSql = filledSql;
         preparedStatement = true;
diff --git a/jdbc-perf-logger-driver/src/test/java/ch/sla/jdbcperflogger/driver/WrappingDriverTest.java b/jdbc-perf-logger-driver/src/test/java/ch/sla/jdbcperflogger/driver/WrappingDriverTest.java
@@ -109,6 +109,17 @@ public void testSelectNonPrepared() throws Exception {
         statement.close();
     }
 
+    @Test
+    public void testTimeoutSelectNonPrepared() throws Exception {
+        final Statement statement = connection.createStatement();
+        statement.setQueryTimeout(123);
+        statement.execute("create table test (key_id int);");
+        final StatementLog statementLog = (StatementLog) lastLogMessage2;
+        assert statementLog != null;
+        assertEquals(123, statementLog.getTimeout());
+        statement.close();
+    }
+
     @SuppressWarnings("null")
     @Test
     public void testExecutePrepared() throws Exception {
diff --git a/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/db/LogRepositoryConstants.java b/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/db/LogRepositoryConstants.java
@@ -12,6 +12,7 @@ public class LogRepositoryConstants {
     public static final String EXEC_PLUS_FETCH_TIME_COLUMN = "EXEC_PLUS_FETCH_TIME";
     public static final String THREAD_NAME_COLUMN = "threadName";
     public static final String CONNECTION_NUMBER_COLUMN = "connectionNumber";
+    public static final String TIMEOUT_COLUMN = "TIMEOUT";
     public static final String ERROR_COLUMN = "ERROR";
     public static final String EXEC_COUNT_COLUMN = "EXEC_COUNT";
     public static final String TOTAL_EXEC_TIME_COLUMN = "TOTAL_EXEC_TIME";
diff --git a/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/db/LogRepositoryReadJdbc.java b/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/db/LogRepositoryReadJdbc.java
@@ -61,7 +61,7 @@ public void getStatements(final LogSearchCriteria searchCriteria, final ResultSe
             final boolean withFilledSql) {
         final StringBuilder sql = new StringBuilder("select id, tstamp, statementType, rawSql, " //
                 + "exec_plus_fetch_time, execution_time, fetch_time, "//
-                + "nbRowsIterated, threadName, connectionNumber, error ");
+                + "nbRowsIterated, threadName, connectionNumber, timeout, error ");
         if (withFilledSql) {
             sql.append(", " + LogRepositoryConstants.FILLED_SQL_COLUMN);
         }
diff --git a/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/db/LogRepositoryUpdateJdbc.java b/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/db/LogRepositoryUpdateJdbc.java
@@ -77,8 +77,8 @@ public LogRepositoryUpdateJdbc(final String name) {
 
             addStatementLog = connectionUpdate
                     .prepareStatement("insert into statement_log (logId, tstamp, statementType, rawSql, filledSql, " //
-                            + "threadName, connectionId)"//
-                            + " values(?, ?, ?, ?, ?, ?, ?)");
+                            + "threadName, connectionId, timeout)"//
+                            + " values(?, ?, ?, ?, ?, ?, ?, ?)");
             updateStatementLogWithResultSet = connectionUpdate
                     .prepareStatement("update statement_log set fetchDurationNanos=?, nbRowsIterated=? where logId=?");
             updateStatementLogAfterExecution = connectionUpdate
@@ -172,6 +172,7 @@ public synchronized void addStatementLog(final StatementLog log) {
             addStatementLog.setString(i++, log.getFilledSql());
             addStatementLog.setString(i++, log.getThreadName());
             addStatementLog.setObject(i++, log.getConnectionUuid());
+            addStatementLog.setInt(i++, log.getTimeout());
             addStatementLog.execute();
         } catch (final SQLException e) {
             throw new RuntimeException(e);
diff --git a/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/ui/PerfLoggerPanel.java b/jdbc-perf-logger-gui/src/main/java/ch/sla/jdbcperflogger/console/ui/PerfLoggerPanel.java
@@ -87,6 +87,7 @@ public class PerfLoggerPanel extends JPanel {
         COLUMNS_WIDTH.put(LogRepositoryConstants.THREAD_NAME_COLUMN, 200);
         COLUMNS_WIDTH.put(LogRepositoryConstants.EXEC_COUNT_COLUMN, 100);
         COLUMNS_WIDTH.put(LogRepositoryConstants.TOTAL_EXEC_TIME_COLUMN, 100);
+        COLUMNS_WIDTH.put(LogRepositoryConstants.TIMEOUT_COLUMN, 70);
         COLUMNS_WIDTH.put(LogRepositoryConstants.ERROR_COLUMN, 0);
     }
 
diff --git a/jdbc-perf-logger-gui/src/main/resources/initdb.sql b/jdbc-perf-logger-gui/src/main/resources/initdb.sql
@@ -13,7 +13,7 @@ create table if not exists statement_log
     (id identity, connectionId UUID not null, logId UUID not null, tstamp timestamp not null, statementType tinyInt not null, 
     rawSql varchar not null, filledSql varchar not null, 
     executionDurationNanos bigInt, fetchDurationNanos bigInt, nbRowsIterated int, 
-    threadName varchar, exception other);
+    threadName varchar, exception other, timeout int);
 
 create index if not exists idx_logId on statement_log(logId);
 create index if not exists idx_duration on statement_log(executionDurationNanos desc);
@@ -27,13 +27,14 @@ create table if not exists batched_statement_log
 create index if not exists idx_batched_logId on batched_statement_log(logId);
 
 create or replace view v_statement_log
-    (id, tstamp, statementType, rawSql, filledSql, exec_plus_fetch_time, execution_time, fetch_time, nbRowsIterated, threadName, error, connectionNumber)
+    (id, tstamp, statementType, rawSql, filledSql, exec_plus_fetch_time, execution_time, fetch_time, nbRowsIterated, threadName, timeout, error, connectionNumber)
   as select statement_log.id, statement_log.tstamp, statement_log.statementType, statement_log.rawSql, statement_log.filledSql,
             statement_log.executionDurationNanos+coalesce(statement_log.fetchDurationNanos,0) as exec_plus_fetch_time,
             statement_log.executionDurationNanos as execution_time, 
             statement_log.fetchDurationNanos as fetch_time,
             statement_log.nbRowsIterated,
             statement_log.threadName,
+            statement_log.timeout,
             NVL2(statement_log.exception, 1, 0),
             connection_info.connectionNumber
         from statement_log join connection_info on (connection_info.connectionId=statement_log.connectionId);
diff --git a/jdbc-perf-logger-gui/src/test/java/ch/sla/jdbcperflogger/console/db/LogRepositoryUpdateJdbcTest.java b/jdbc-perf-logger-gui/src/test/java/ch/sla/jdbcperflogger/console/db/LogRepositoryUpdateJdbcTest.java
@@ -49,7 +49,7 @@ public void testSetup() {
     @Test
     public void testInsertAndRead() {
         final StatementLog log = new StatementLog(UUID.randomUUID(), UUID.randomUUID(), System.currentTimeMillis(),
-                StatementType.BASE_NON_PREPARED_STMT, "myrawsql", Thread.currentThread().getName());
+                StatementType.BASE_NON_PREPARED_STMT, "myrawsql", Thread.currentThread().getName(), 123);
         repositoryUpdate.addStatementLog(log);
         repositoryUpdate.addStatementLog(log);
         repositoryRead.getStatementLog(1);

Original file line number	Diff line number	Diff line change
`@@ -73,18 +73,18 @@ public class PerfLogger {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public static void logBeforeStatement(final UUID connectionId, final UUID logId, final String sql,`
`76`		`- final StatementType statementType) {`
	`76`	`+ final StatementType statementType, final int timeout) {`
`77`	`77`	`if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {`
`78`	`78`	`LOGGER_ORIGINAL_SQL.debug("Before execution of non-prepared stmt {}: {}", logId, sql);`
`79`	`79`	`}`
`80`	`80`	`final long now = System.currentTimeMillis();`
`81`	`81`	`PerfLoggerRemoting.postLog(new StatementLog(connectionId, logId, now, statementType, sql, Thread`
`82`		`- .currentThread().getName()));`
	`82`	`+ .currentThread().getName(), timeout));`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`public static void logBeforePreparedStatement(final UUID connectionId, final UUID logId, final String rawSql,`
`86`	`86`	`final PreparedStatementValuesHolder pstmtValues, final StatementType statementType,`
`87`		`- final DatabaseType databaseType) {`
	`87`	`+ final DatabaseType databaseType, final int timeout) {`
`88`	`88`	`if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {`
`89`	`89`	`LOGGER_ORIGINAL_SQL.debug("Before execution of prepared stmt {}: {}", logId, rawSql);`
`90`	`90`	`}`
`@@ -94,11 +94,11 @@ public static void logBeforePreparedStatement(final UUID connectionId, final UUI`
`94`	`94`	`}`
`95`	`95`	`final long now = System.currentTimeMillis();`
`96`	`96`	`PerfLoggerRemoting.postLog(new StatementLog(connectionId, logId, now, statementType, rawSql, filledSql, Thread`
`97`		`- .currentThread().getName()));`
	`97`	`+ .currentThread().getName(), timeout));`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`public static void logNonPreparedBatchedStatements(final UUID connectionId, final UUID logId,`
`101`		`- final List<String> batchedExecutions, final DatabaseType databaseType) {`
	`101`	`+ final List<String> batchedExecutions, final DatabaseType databaseType, final int timeout) {`
`102`	`102`
`103`	`103`	`final long now = System.currentTimeMillis();`
`104`	`104`	`if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {`
`@@ -112,11 +112,11 @@ public static void logNonPreparedBatchedStatements(final UUID connectionId, fina`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`	`PerfLoggerRemoting.postLog(new BatchedNonPreparedStatementsLog(connectionId, logId, now, batchedExecutions,`
`115`		`- Thread.currentThread().getName()));`
	`115`	`+ Thread.currentThread().getName(), timeout));`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`public static void logPreparedBatchedStatements(final UUID connectionId, final String rawSql,`
`119`		`- final List<Object> batchedExecutions, final DatabaseType databaseType) {`
	`119`	`+ final List<Object> batchedExecutions, final DatabaseType databaseType, final int timeout) {`
`120`	`120`	`final long now = System.currentTimeMillis();`
`121`	`121`	`if (LOGGER_ORIGINAL_SQL.isDebugEnabled()) {`
`122`	`122`	`LOGGER_ORIGINAL_SQL.debug("Before execution of {} batched prepared statements with raw sql {}",`
`@@ -138,7 +138,7 @@ public static void logPreparedBatchedStatements(final UUID connectionId, final S`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`	`PerfLoggerRemoting.postLog(new BatchedPreparedStatementsLog(connectionId, UUID.randomUUID(), now, rawSql,`
`141`		`- filledSqlList, Thread.currentThread().getName()));`
	`141`	`+ filledSqlList, Thread.currentThread().getName(), timeout));`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`public static void logStatementExecuted(final UUID logId, final long durationNanos,`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,8 @@ public class BatchedNonPreparedStatementsLog extends AbstractBeforeStatementExec`
`29`	`29`	`private final List<String> sqlList;`
`30`	`30`
`31`	`31`	`public BatchedNonPreparedStatementsLog(final UUID connectionId, final UUID logId, final long timestamp,`
`32`		`- final List<String> sqlList, final String threadName) {`
`33`		`- super(connectionId, logId, timestamp, StatementType.NON_PREPARED_BATCH_EXECUTION, threadName);`
	`32`	`+ final List<String> sqlList, final String threadName, final int timeout) {`
	`33`	`+ super(connectionId, logId, timestamp, StatementType.NON_PREPARED_BATCH_EXECUTION, threadName, timeout);`
`34`	`34`	`this.sqlList = Collections.unmodifiableList(new ArrayList<String>(sqlList));`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ public void getStatements(final LogSearchCriteria searchCriteria, final ResultSe`
`61`	`61`	`final boolean withFilledSql) {`
`62`	`62`	`final StringBuilder sql = new StringBuilder("select id, tstamp, statementType, rawSql, " //`
`63`	`63`	`+ "exec_plus_fetch_time, execution_time, fetch_time, "//`
`64`		`- + "nbRowsIterated, threadName, connectionNumber, error ");`
	`64`	`+ + "nbRowsIterated, threadName, connectionNumber, timeout, error ");`
`65`	`65`	`if (withFilledSql) {`
`66`	`66`	`sql.append(", " + LogRepositoryConstants.FILLED_SQL_COLUMN);`
`67`	`67`	`}`