org.mariadb.jdbc.ClientPreparedStatement Maven / Gradle / Ivy
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (c) 2012-2014 Monty Program Ab
// Copyright (c) 2015-2021 MariaDB Corporation Ab
package org.mariadb.jdbc;
import static org.mariadb.jdbc.util.constants.Capabilities.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.locks.ReentrantLock;
import org.mariadb.jdbc.client.ColumnDecoder;
import org.mariadb.jdbc.client.Completion;
import org.mariadb.jdbc.client.result.CompleteResult;
import org.mariadb.jdbc.client.result.Result;
import org.mariadb.jdbc.export.ExceptionFactory;
import org.mariadb.jdbc.message.ClientMessage;
import org.mariadb.jdbc.message.client.*;
import org.mariadb.jdbc.message.server.OkPacket;
import org.mariadb.jdbc.message.server.PrepareResultPacket;
import org.mariadb.jdbc.util.ClientParser;
import org.mariadb.jdbc.util.ParameterList;
import org.mariadb.jdbc.util.constants.ServerStatus;
/**
* Client side prepare statement. Question mark will be replaced by escaped parameters, client side
*/
public class ClientPreparedStatement extends BasePreparedStatement {
private final ClientParser parser;
/**
* Client prepare statement constructor
*
* @param sql command
* @param con connection
* @param lock thread safe lock
* @param canUseServerTimeout can server use timeout
* @param canUseServerMaxRows can server use max rows
* @param autoGeneratedKeys must command return automatically generated keys
* @param resultSetType resultset type
* @param resultSetConcurrency resultset concurrency
* @param defaultFetchSize default fetch size
*/
public ClientPreparedStatement(
String sql,
Connection con,
ReentrantLock lock,
boolean canUseServerTimeout,
boolean canUseServerMaxRows,
int autoGeneratedKeys,
int resultSetType,
int resultSetConcurrency,
int defaultFetchSize) {
super(
sql,
con,
lock,
canUseServerTimeout,
canUseServerMaxRows,
autoGeneratedKeys,
resultSetType,
resultSetConcurrency,
defaultFetchSize);
boolean noBackslashEscapes =
(con.getContext().getServerStatus() & ServerStatus.NO_BACKSLASH_ESCAPES) > 0;
parser = ClientParser.parameterParts(sql, noBackslashEscapes);
parameters = new ParameterList(parser.getParamCount());
}
/**
* use additional part for timeout if possible
*
* @return pre command for handling timeout
*/
protected String preSqlCmd() {
if (queryTimeout != 0 && canUseServerTimeout) {
return "SET STATEMENT max_statement_time=" + queryTimeout + " FOR ";
}
return null;
}
private void executeInternal() throws SQLException {
checkNotClosed();
validParameters();
lock.lock();
try {
QueryWithParametersPacket query =
new QueryWithParametersPacket(preSqlCmd(), parser, parameters, localInfileInputStream);
results =
con.getClient()
.execute(
query,
this,
fetchSize,
maxRows,
resultSetConcurrency,
resultSetType,
closeOnCompletion,
false);
} finally {
localInfileInputStream = null;
lock.unlock();
}
}
private void executeInternalPreparedBatch() throws SQLException {
checkNotClosed();
if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS
&& batchParameters.size() > 1
&& con.getContext().hasClientCapability(STMT_BULK_OPERATIONS)) {
executeBatchBulk();
} else {
boolean possibleLoadLocal = con.getContext().hasClientCapability(LOCAL_FILES);
if (possibleLoadLocal) {
String sqlUpper = sql.toUpperCase(Locale.ROOT);
possibleLoadLocal =
sqlUpper.contains(" LOCAL ")
&& sqlUpper.contains("LOAD")
&& sqlUpper.contains(" INFILE");
}
if (possibleLoadLocal) {
executeBatchStd();
} else {
executeBatchPipeline();
}
}
}
/**
* Send COM_STMT_PREPARE + X * COM_STMT_BULK_EXECUTE, then read for the all answers
*
* @throws SQLException if IOException / Command error
*/
private void executeBatchBulk() throws SQLException {
String cmd = escapeTimeout(sql);
try {
if (prepareResult == null) {
ClientMessage[] packets =
new ClientMessage[] {
new PreparePacket(cmd), new BulkExecutePacket(null, batchParameters, cmd, null)
};
List res =
con.getClient()
.executePipeline(
packets,
this,
0,
maxRows,
ResultSet.CONCUR_READ_ONLY,
ResultSet.TYPE_FORWARD_ONLY,
closeOnCompletion,
false);
// in case of failover, prepare is done in failover, skipping prepare result
if (res.get(0) instanceof PrepareResultPacket) {
results = res.subList(1, res.size());
} else {
results = res;
}
} else {
results =
con.getClient()
.execute(
new BulkExecutePacket(prepareResult, batchParameters, cmd, null),
this,
fetchSize,
maxRows,
resultSetConcurrency,
resultSetType,
closeOnCompletion,
false);
}
} catch (SQLException bue) {
results = null;
throw exceptionFactory()
.createBatchUpdate(Collections.emptyList(), batchParameters.size(), bue);
}
}
/**
* Send n * COM_QUERY + n * read answer
*
* @throws SQLException if IOException / Command error
*/
private void executeBatchPipeline() throws SQLException {
ClientMessage[] packets = new ClientMessage[batchParameters.size()];
for (int i = 0; i < batchParameters.size(); i++) {
packets[i] = new QueryWithParametersPacket(preSqlCmd(), parser, batchParameters.get(i), null);
}
try {
results =
con.getClient()
.executePipeline(
packets,
this,
0,
maxRows,
ResultSet.CONCUR_READ_ONLY,
ResultSet.TYPE_FORWARD_ONLY,
closeOnCompletion,
false);
} catch (SQLException bue) {
results = null;
throw bue;
}
}
/**
* Send n * (COM_QUERY + read answer)
*
* @throws SQLException if IOException / Command error
*/
private void executeBatchStd() throws SQLException {
int i = 0;
try {
results = new ArrayList<>();
for (; i < batchParameters.size(); i++) {
results.addAll(
con.getClient()
.execute(
new QueryWithParametersPacket(
preSqlCmd(), parser, batchParameters.get(i), localInfileInputStream),
this,
0,
maxRows,
ResultSet.CONCUR_READ_ONLY,
ResultSet.TYPE_FORWARD_ONLY,
closeOnCompletion,
false));
}
} catch (SQLException bue) {
BatchUpdateException exception =
exceptionFactory().createBatchUpdate(results, batchParameters.size(), bue);
results = null;
localInfileInputStream = null;
throw exception;
}
}
/**
* Executes the SQL statement in this PreparedStatement object, which may be any kind
* of SQL statement. Some prepared statements return multiple results; the execute
* method handles these complex statements as well as the simpler form of statements handled by
* the methods executeQuery and executeUpdate.
*
* The execute method returns a boolean to indicate the form of the
* first result. You must call either the method getResultSet or getUpdateCount
* to retrieve the result; you must call getMoreResults to move to any
* subsequent result(s).
*
* @return true if the first result is a ResultSet object; false
* if the first result is an update count or there is no result
* @throws SQLException if a database access error occurs; this method is called on a closed
* PreparedStatement or an argument is supplied to this method
* @throws SQLTimeoutException when the driver has determined that the timeout value that was
* specified by the {@code setQueryTimeout} method has been exceeded and has at least
* attempted to cancel the currently running {@code Statement}
* @see Statement#execute
* @see Statement#getResultSet
* @see Statement#getUpdateCount
* @see Statement#getMoreResults
*/
@Override
public boolean execute() throws SQLException {
executeInternal();
currResult = results.remove(0);
return currResult instanceof Result;
}
/**
* Executes the SQL query in this PreparedStatement object and returns the
* ResultSet object generated by the query.
*
* @return a ResultSet object that contains the data produced by the query; never
* null
* @throws SQLException if a database access error occurs; this method is called on a closed
* PreparedStatement or the SQL statement does not return a ResultSet
* object
* @throws SQLTimeoutException when the driver has determined that the timeout value that was
* specified by the {@code setQueryTimeout} method has been exceeded and has at least
* attempted to cancel the currently running {@code Statement}
*/
@Override
public ResultSet executeQuery() throws SQLException {
executeInternal();
currResult = results.remove(0);
if (currResult instanceof Result) {
return (Result) currResult;
}
return new CompleteResult(new ColumnDecoder[0], new byte[0][], con.getContext());
}
/**
* Executes the SQL statement in this PreparedStatement object, which must be an SQL
* Data Manipulation Language (DML) statement, such as INSERT, UPDATE or
* DELETE; or an SQL statement that returns nothing, such as a DDL statement.
*
* @return either (1) the row count for SQL Data Manipulation Language (DML) statements or (2) 0
* for SQL statements that return nothing
* @throws SQLException if a database access error occurs; this method is called on a closed
* PreparedStatement or the SQL statement returns a ResultSet object
* @throws SQLTimeoutException when the driver has determined that the timeout value that was
* specified by the {@code setQueryTimeout} method has been exceeded and has at least
* attempted to cancel the currently running {@code Statement}
*/
@Override
public int executeUpdate() throws SQLException {
return (int) executeLargeUpdate();
}
/**
* Executes the SQL statement in this PreparedStatement object, which must be an SQL
* Data Manipulation Language (DML) statement, such as INSERT, UPDATE or
* DELETE; or an SQL statement that returns nothing, such as a DDL statement.
*
*
This method should be used when the returned row count may exceed {@link Integer#MAX_VALUE}.
*
*
The default implementation will throw {@code UnsupportedOperationException}
*
* @return either (1) the row count for SQL Data Manipulation Language (DML) statements or (2) 0
* for SQL statements that return nothing
* @throws SQLException if a database access error occurs; this method is called on a closed
* PreparedStatement or the SQL statement returns a ResultSet object
* @throws SQLTimeoutException when the driver has determined that the timeout value that was
* specified by the {@code setQueryTimeout} method has been exceeded and has at least
* attempted to cancel the currently running {@code Statement}
* @since 1.8
*/
@Override
public long executeLargeUpdate() throws SQLException {
executeInternal();
currResult = results.remove(0);
if (currResult instanceof Result) {
throw exceptionFactory()
.create("the given SQL statement produces an unexpected ResultSet object", "HY000");
}
return ((OkPacket) currResult).getAffectedRows();
}
private ExceptionFactory exceptionFactory() {
return con.getExceptionFactory().of(this);
}
/**
* Adds a set of parameters to this PreparedStatement object's batch of commands.
*
* @throws SQLException if a database access error occurs or this method is called on a closed
* PreparedStatement
* @see Statement#addBatch
* @since 1.2
*/
@Override
public void addBatch() throws SQLException {
validParameters();
if (batchParameters == null) batchParameters = new ArrayList<>();
batchParameters.add(parameters);
parameters = parameters.clone();
}
/**
* Validate parameter number according to expected parameter.
*
* @throws SQLException if doesn't correspond
*/
protected void validParameters() throws SQLException {
for (int i = 0; i < parser.getParamCount(); i++) {
if (!parameters.containsKey(i)) {
throw exceptionFactory()
.create("Parameter at position " + (i + 1) + " is not set", "07004");
}
}
}
@Override
public void setQueryTimeout(int seconds) throws SQLException {
super.setQueryTimeout(seconds);
if (canUseServerTimeout && prepareResult != null) {
prepareResult.close(con.getClient());
prepareResult = null;
}
}
@Override
public void setMaxRows(int max) throws SQLException {
super.setMaxRows(max);
if (canUseServerMaxRows && prepareResult != null) {
prepareResult.close(con.getClient());
prepareResult = null;
}
}
@Override
public void setLargeMaxRows(long max) throws SQLException {
super.setLargeMaxRows(max);
if (canUseServerMaxRows && prepareResult != null) {
prepareResult.close(con.getClient());
prepareResult = null;
}
}
/**
* Retrieves a ResultSetMetaData object that contains information about the columns
* of the ResultSet object that will be returned when this PreparedStatement
* object is executed.
*
*
Because a PreparedStatement object is precompiled, it is possible to know about
* the ResultSet object that it will return without having to execute it.
* Consequently, it is possible to invoke the method getMetaData on a
* PreparedStatement object rather than waiting to execute it and then invoking the
* ResultSet.getMetaData method on the ResultSet object that is returned.
*
*
NOTE: Using this method may be expensive for some drivers due to the lack of
* underlying DBMS support.
*
* @return the description of a ResultSet object's columns or null if
* the driver cannot return a ResultSetMetaData object
* @throws SQLException if a database access error occurs or this method is called on a closed
* PreparedStatement
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.2
*/
@Override
public ResultSetMetaData getMetaData() throws SQLException {
// send COM_STMT_PREPARE
if (prepareResult == null)
con.getClient().execute(new PreparePacket(escapeTimeout(sql)), this, true);
return new org.mariadb.jdbc.client.result.ResultSetMetaData(
exceptionFactory(), prepareResult.getColumns(), con.getContext().getConf(), false);
}
/**
* Retrieves the number, types and properties of this PreparedStatement object's
* parameters.
*
* @return a ParameterMetaData object that contains information about the number,
* types and properties for each parameter marker of this PreparedStatement
* object
* @throws SQLException if a database access error occurs or this method is called on a closed
* PreparedStatement
* @see ParameterMetaData
* @since 1.4
*/
@Override
public java.sql.ParameterMetaData getParameterMetaData() throws SQLException {
// send COM_STMT_PREPARE
if (prepareResult == null) {
try {
con.getClient().execute(new PreparePacket(escapeTimeout(sql)), this, true);
} catch (SQLException e) {
return new SimpleParameterMetaData(exceptionFactory(), parser.getParamCount());
}
}
return new ParameterMetaData(exceptionFactory(), prepareResult.getParameters());
}
@Override
public int[] executeBatch() throws SQLException {
checkNotClosed();
if (batchParameters == null || batchParameters.isEmpty()) return new int[0];
lock.lock();
try {
executeInternalPreparedBatch();
int[] updates = new int[batchParameters.size()];
if (results.size() != batchParameters.size()) {
for (int i = 0; i < batchParameters.size(); i++) {
updates[i] = Statement.SUCCESS_NO_INFO;
}
} else {
for (int i = 0; i < updates.length; i++) {
if (results.get(i) instanceof OkPacket) {
updates[i] = (int) ((OkPacket) results.get(i)).getAffectedRows();
} else {
updates[i] = org.mariadb.jdbc.Statement.SUCCESS_NO_INFO;
}
}
}
currResult = results.remove(0);
return updates;
} finally {
batchParameters.clear();
lock.unlock();
}
}
@Override
public long[] executeLargeBatch() throws SQLException {
checkNotClosed();
if (batchParameters == null || batchParameters.isEmpty()) return new long[0];
lock.lock();
try {
executeInternalPreparedBatch();
long[] updates = new long[results.size()];
for (int i = 0; i < results.size(); i++) {
updates[i] = ((OkPacket) results.get(i)).getAffectedRows();
}
currResult = results.remove(0);
return updates;
} finally {
batchParameters.clear();
lock.unlock();
}
}
@Override
public void close() throws SQLException {
if (prepareResult != null) {
lock.lock();
try {
prepareResult.close(this.con.getClient());
} finally {
lock.unlock();
}
}
con.fireStatementClosed(this);
super.close();
}
@Override
public String toString() {
return "ClientPreparedStatement{" + super.toString() + '}';
}
}