Examples with MySQLTimeoutException com.mysql.cj.jdbc.exceptions.MySQLTimeoutException used on opensource projects

Example 6 with MySQLTimeoutException

use of com.mysql.cj.jdbc.exceptions.MySQLTimeoutException in project JavaSegundasQuintas by ecteruel.

the class StatementImpl method executeBatchInternal.

protected long[] executeBatchInternal() throws SQLException {
    JdbcConnection locallyScopedConn = checkClosed();
    synchronized (locallyScopedConn.getConnectionMutex()) {
        if (locallyScopedConn.isReadOnly()) {
            throw SQLError.createSQLException(Messages.getString("Statement.34") + Messages.getString("Statement.35"), MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
        }
        implicitlyCloseAllOpenResults();
        List<Object> batchedArgs = this.query.getBatchedArgs();
        if (batchedArgs == null || batchedArgs.size() == 0) {
            return new long[0];
        }
        // we timeout the entire batch, not individual statements
        int individualStatementTimeout = getTimeoutInMillis();
        setTimeoutInMillis(0);
        CancelQueryTask timeoutTask = null;
        try {
            resetCancelledState();
            statementBegins();
            try {
                // The JDBC spec doesn't forbid this, but doesn't provide for it either...we do..
                this.retrieveGeneratedKeys = true;
                long[] updateCounts = null;
                if (batchedArgs != null) {
                    int nbrCommands = batchedArgs.size();
                    this.batchedGeneratedKeys = new ArrayList<>(batchedArgs.size());
                    boolean multiQueriesEnabled = locallyScopedConn.getPropertySet().getBooleanProperty(PropertyKey.allowMultiQueries).getValue();
                    if (multiQueriesEnabled || (locallyScopedConn.getPropertySet().getBooleanProperty(PropertyKey.rewriteBatchedStatements).getValue() && nbrCommands > 4)) {
                        return executeBatchUsingMultiQueries(multiQueriesEnabled, nbrCommands, individualStatementTimeout);
                    }
                    timeoutTask = startQueryTimer(this, individualStatementTimeout);
                    updateCounts = new long[nbrCommands];
                    for (int i = 0; i < nbrCommands; i++) {
                        updateCounts[i] = -3;
                    }
                    SQLException sqlEx = null;
                    int commandIndex = 0;
                    for (commandIndex = 0; commandIndex < nbrCommands; commandIndex++) {
                        try {
                            String sql = (String) batchedArgs.get(commandIndex);
                            updateCounts[commandIndex] = executeUpdateInternal(sql, true, true);
                            if (timeoutTask != null) {
                                // we need to check the cancel state on each iteration to generate timeout exception if needed
                                checkCancelTimeout();
                            }
                            // limit one generated key per OnDuplicateKey statement
                            getBatchedGeneratedKeys(this.results.getFirstCharOfQuery() == 'I' && containsOnDuplicateKeyInString(sql) ? 1 : 0);
                        } catch (SQLException ex) {
                            updateCounts[commandIndex] = EXECUTE_FAILED;
                            if (this.continueBatchOnError && !(ex instanceof MySQLTimeoutException) && !(ex instanceof MySQLStatementCancelledException) && !hasDeadlockOrTimeoutRolledBackTx(ex)) {
                                sqlEx = ex;
                            } else {
                                long[] newUpdateCounts = new long[commandIndex];
                                if (hasDeadlockOrTimeoutRolledBackTx(ex)) {
                                    for (int i = 0; i < newUpdateCounts.length; i++) {
                                        newUpdateCounts[i] = java.sql.Statement.EXECUTE_FAILED;
                                    }
                                } else {
                                    System.arraycopy(updateCounts, 0, newUpdateCounts, 0, commandIndex);
                                }
                                sqlEx = ex;
                                break;
                            // throw SQLError.createBatchUpdateException(ex, newUpdateCounts, getExceptionInterceptor());
                            }
                        }
                    }
                    if (sqlEx != null) {
                        throw SQLError.createBatchUpdateException(sqlEx, updateCounts, getExceptionInterceptor());
                    }
                }
                if (timeoutTask != null) {
                    stopQueryTimer(timeoutTask, true, true);
                    timeoutTask = null;
                }
                return (updateCounts != null) ? updateCounts : new long[0];
            } finally {
                this.query.getStatementExecuting().set(false);
            }
        } finally {
            stopQueryTimer(timeoutTask, false, false);
            resetCancelledState();
            setTimeoutInMillis(individualStatementTimeout);
            clearBatch();
        }
    }
}

Example 7 with MySQLTimeoutException

use of com.mysql.cj.jdbc.exceptions.MySQLTimeoutException in project aws-mysql-jdbc by awslabs.

the class ClientPreparedStatement method executeBatchSerially.

/**
 * Executes the current batch of statements by executing them one-by-one.
 *
 * @param batchTimeout
 *            timeout for the batch execution
 * @return a list of update counts
 * @throws SQLException
 *             if an error occurs
 */
protected long[] executeBatchSerially(int batchTimeout) throws SQLException {
    synchronized (checkClosed().getConnectionMutex()) {
        if (this.connection == null) {
            checkClosed();
        }
        long[] updateCounts = null;
        if (this.query.getBatchedArgs() != null) {
            int nbrCommands = this.query.getBatchedArgs().size();
            updateCounts = new long[nbrCommands];
            for (int i = 0; i < nbrCommands; i++) {
                updateCounts[i] = -3;
            }
            SQLException sqlEx = null;
            CancelQueryTask timeoutTask = null;
            try {
                timeoutTask = startQueryTimer(this, batchTimeout);
                if (this.retrieveGeneratedKeys) {
                    this.batchedGeneratedKeys = new ArrayList<>(nbrCommands);
                }
                int batchCommandIndex = ((PreparedQuery<?>) this.query).getBatchCommandIndex();
                for (batchCommandIndex = 0; batchCommandIndex < nbrCommands; batchCommandIndex++) {
                    ((PreparedQuery<?>) this.query).setBatchCommandIndex(batchCommandIndex);
                    Object arg = this.query.getBatchedArgs().get(batchCommandIndex);
                    try {
                        if (arg instanceof String) {
                            updateCounts[batchCommandIndex] = executeUpdateInternal((String) arg, true, this.retrieveGeneratedKeys);
                            // limit one generated key per OnDuplicateKey statement
                            getBatchedGeneratedKeys(this.results.getFirstCharOfQuery() == 'I' && containsOnDuplicateKeyInString((String) arg) ? 1 : 0);
                        } else {
                            QueryBindings<?> queryBindings = (QueryBindings<?>) arg;
                            updateCounts[batchCommandIndex] = executeUpdateInternal(queryBindings, true);
                            // limit one generated key per OnDuplicateKey statement
                            getBatchedGeneratedKeys(containsOnDuplicateKeyUpdateInSQL() ? 1 : 0);
                        }
                    } catch (SQLException ex) {
                        updateCounts[batchCommandIndex] = EXECUTE_FAILED;
                        if (this.continueBatchOnError && !(ex instanceof MySQLTimeoutException) && !(ex instanceof MySQLStatementCancelledException) && !hasDeadlockOrTimeoutRolledBackTx(ex)) {
                            sqlEx = ex;
                        } else {
                            long[] newUpdateCounts = new long[batchCommandIndex];
                            System.arraycopy(updateCounts, 0, newUpdateCounts, 0, batchCommandIndex);
                            throw SQLError.createBatchUpdateException(ex, newUpdateCounts, this.exceptionInterceptor);
                        }
                    }
                }
                if (sqlEx != null) {
                    throw SQLError.createBatchUpdateException(sqlEx, updateCounts, this.exceptionInterceptor);
                }
            } catch (NullPointerException npe) {
                try {
                    checkClosed();
                } catch (StatementIsClosedException connectionClosedEx) {
                    int batchCommandIndex = ((PreparedQuery<?>) this.query).getBatchCommandIndex();
                    updateCounts[batchCommandIndex] = EXECUTE_FAILED;
                    long[] newUpdateCounts = new long[batchCommandIndex];
                    System.arraycopy(updateCounts, 0, newUpdateCounts, 0, batchCommandIndex);
                    throw SQLError.createBatchUpdateException(SQLExceptionsMapping.translateException(connectionClosedEx), newUpdateCounts, this.exceptionInterceptor);
                }
                // we don't know why this happened, punt
                throw npe;
            } finally {
                ((PreparedQuery<?>) this.query).setBatchCommandIndex(-1);
                stopQueryTimer(timeoutTask, false, false);
                resetCancelledState();
            }
        }
        return (updateCounts != null) ? updateCounts : new long[0];
    }
}

Example 8 with MySQLTimeoutException

use of com.mysql.cj.jdbc.exceptions.MySQLTimeoutException in project aws-mysql-jdbc by awslabs.

the class ServerPreparedStatement method executeBatchSerially.

@Override
protected long[] executeBatchSerially(int batchTimeout) throws SQLException {
    synchronized (checkClosed().getConnectionMutex()) {
        JdbcConnection locallyScopedConn = this.connection;
        if (locallyScopedConn.isReadOnly()) {
            throw SQLError.createSQLException(Messages.getString("ServerPreparedStatement.2") + Messages.getString("ServerPreparedStatement.3"), MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
        }
        clearWarnings();
        // Store this for later, we're going to 'swap' them out
        // as we execute each batched statement...
        ServerPreparedQueryBindValue[] oldBindValues = ((ServerPreparedQuery) this.query).getQueryBindings().getBindValues();
        try {
            long[] updateCounts = null;
            if (this.query.getBatchedArgs() != null) {
                int nbrCommands = this.query.getBatchedArgs().size();
                updateCounts = new long[nbrCommands];
                if (this.retrieveGeneratedKeys) {
                    this.batchedGeneratedKeys = new ArrayList<>(nbrCommands);
                }
                for (int i = 0; i < nbrCommands; i++) {
                    updateCounts[i] = -3;
                }
                SQLException sqlEx = null;
                int commandIndex = 0;
                ServerPreparedQueryBindValue[] previousBindValuesForBatch = null;
                CancelQueryTask timeoutTask = null;
                try {
                    timeoutTask = startQueryTimer(this, batchTimeout);
                    for (commandIndex = 0; commandIndex < nbrCommands; commandIndex++) {
                        Object arg = this.query.getBatchedArgs().get(commandIndex);
                        try {
                            if (arg instanceof String) {
                                updateCounts[commandIndex] = executeUpdateInternal((String) arg, true, this.retrieveGeneratedKeys);
                                // limit one generated key per OnDuplicateKey statement
                                getBatchedGeneratedKeys(this.results.getFirstCharOfQuery() == 'I' && containsOnDuplicateKeyInString((String) arg) ? 1 : 0);
                            } else {
                                ((ServerPreparedQuery) this.query).setQueryBindings((ServerPreparedQueryBindings) arg);
                                ServerPreparedQueryBindValue[] parameterBindings = ((ServerPreparedQuery) this.query).getQueryBindings().getBindValues();
                                if (previousBindValuesForBatch != null) {
                                    for (int j = 0; j < parameterBindings.length; j++) {
                                        if (parameterBindings[j].bufferType != previousBindValuesForBatch[j].bufferType) {
                                            ((ServerPreparedQuery) this.query).getQueryBindings().getSendTypesToServer().set(true);
                                            break;
                                        }
                                    }
                                }
                                try {
                                    updateCounts[commandIndex] = executeUpdateInternal(false, true);
                                } finally {
                                    previousBindValuesForBatch = parameterBindings;
                                }
                                // limit one generated key per OnDuplicateKey statement
                                getBatchedGeneratedKeys(containsOnDuplicateKeyUpdateInSQL() ? 1 : 0);
                            }
                        } catch (SQLException ex) {
                            updateCounts[commandIndex] = EXECUTE_FAILED;
                            if (this.continueBatchOnError && !(ex instanceof MySQLTimeoutException) && !(ex instanceof MySQLStatementCancelledException) && !hasDeadlockOrTimeoutRolledBackTx(ex)) {
                                sqlEx = ex;
                            } else {
                                long[] newUpdateCounts = new long[commandIndex];
                                System.arraycopy(updateCounts, 0, newUpdateCounts, 0, commandIndex);
                                throw SQLError.createBatchUpdateException(ex, newUpdateCounts, this.exceptionInterceptor);
                            }
                        }
                    }
                } finally {
                    stopQueryTimer(timeoutTask, false, false);
                    resetCancelledState();
                }
                if (sqlEx != null) {
                    throw SQLError.createBatchUpdateException(sqlEx, updateCounts, this.exceptionInterceptor);
                }
            }
            return (updateCounts != null) ? updateCounts : new long[0];
        } finally {
            ((ServerPreparedQuery) this.query).getQueryBindings().setBindValues(oldBindValues);
            ((ServerPreparedQuery) this.query).getQueryBindings().getSendTypesToServer().set(true);
            clearBatch();
        }
    }
}

Example 9 with MySQLTimeoutException

use of com.mysql.cj.jdbc.exceptions.MySQLTimeoutException in project aws-mysql-jdbc by awslabs.

the class ExceptionsTest method testConstructors.

@Test
public void testConstructors() {
    new CommunicationsException(TEST_MESSAGE, new Throwable());
    new CommunicationsException((JdbcConnection) this.conn, new PacketSentTimeHolder() {
    }, new PacketReceivedTimeHolder() {
    }, new Exception());
    new ConnectionFeatureNotAvailableException(TEST_MESSAGE, new Throwable());
    new ConnectionFeatureNotAvailableException((JdbcConnection) this.conn, new PacketSentTimeHolder() {
    }, new Exception());
    new MysqlDataTruncation(TEST_MESSAGE, 0, false, false, 0, 0, 0);
    new MySQLQueryInterruptedException();
    new MySQLQueryInterruptedException(TEST_MESSAGE);
    new MySQLQueryInterruptedException(TEST_MESSAGE, TEST_SQL_STATE);
    new MySQLQueryInterruptedException(TEST_MESSAGE, TEST_SQL_STATE, 0);
    new MySQLStatementCancelledException();
    new MySQLStatementCancelledException(TEST_MESSAGE);
    new MySQLStatementCancelledException(TEST_MESSAGE, TEST_SQL_STATE);
    new MySQLStatementCancelledException(TEST_MESSAGE, TEST_SQL_STATE, 0);
    new MySQLTimeoutException();
    new MySQLTimeoutException(TEST_MESSAGE);
    new MySQLTimeoutException(TEST_MESSAGE, TEST_SQL_STATE);
    new MySQLTimeoutException(TEST_MESSAGE, TEST_SQL_STATE, 0);
    new MySQLTransactionRollbackException();
    new MySQLTransactionRollbackException(TEST_MESSAGE);
    new MySQLTransactionRollbackException(TEST_MESSAGE, TEST_SQL_STATE);
    new MySQLTransactionRollbackException(TEST_MESSAGE, TEST_SQL_STATE, 0);
    new NotUpdatable(TEST_MESSAGE);
    new OperationNotSupportedException();
    new OperationNotSupportedException(TEST_MESSAGE);
    new PacketTooBigException(TEST_MESSAGE);
    new PacketTooBigException(0, 100);
    new SQLError();
}

Example 10 with MySQLTimeoutException

use of com.mysql.cj.jdbc.exceptions.MySQLTimeoutException in project aws-mysql-jdbc by awslabs.

the class StatementRegressionTest method testBug22359.

/**
 * Tests fix for BUG#22359 - Driver was using millis for Statement.setQueryTimeout() when spec says argument is seconds.
 *
 * @throws Exception
 */
@Test
public void testBug22359() throws Exception {
    Statement timeoutStmt = null;
    try {
        timeoutStmt = this.conn.createStatement();
        timeoutStmt.setQueryTimeout(2);
        long begin = System.currentTimeMillis();
        try {
            timeoutStmt.execute("SELECT SLEEP(30)");
            fail("Query didn't time out");
        } catch (MySQLTimeoutException timeoutEx) {
            long end = System.currentTimeMillis();
            assertTrue((end - begin) > 1000);
        }
    } finally {
        if (timeoutStmt != null) {
            timeoutStmt.close();
        }
    }
}