/*
Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
The MySQL Connector/J is licensed under the terms of the GPLv2
<http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
this software, see the FLOSS License Exception
<http://www.mysql.com/about/legal/licensing/foss-exception.html>.
This program is free software; you can redistribute it and/or modify it under the terms
of the GNU General Public License as published by the Free Software Foundation; version 2
of the License.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this
program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
Floor, Boston, MA 02110-1301 USA
*/
package com.mysql.jdbc;
import java.io.InputStream;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Constructor;
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.ParameterMetaData;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Representation of stored procedures for JDBC
*
* @author Mark Matthews
* @version $Id: CallableStatement.java,v 1.1.2.1 2005/05/13 18:58:38 mmatthews
* Exp $
*/
public class CallableStatement extends PreparedStatement implements
java.sql.CallableStatement {
protected final static Constructor<?> JDBC_4_CSTMT_2_ARGS_CTOR;
protected final static Constructor<?> JDBC_4_CSTMT_4_ARGS_CTOR;
static {
if (Util.isJdbc4()) {
try {
JDBC_4_CSTMT_2_ARGS_CTOR = Class.forName(
"com.mysql.jdbc.JDBC4CallableStatement")
.getConstructor(
new Class[] { MySQLConnection.class,
CallableStatementParamInfo.class });
JDBC_4_CSTMT_4_ARGS_CTOR = Class.forName(
"com.mysql.jdbc.JDBC4CallableStatement")
.getConstructor(
new Class[] { MySQLConnection.class,
String.class, String.class,
Boolean.TYPE });
} catch (SecurityException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
} else {
JDBC_4_CSTMT_4_ARGS_CTOR = null;
JDBC_4_CSTMT_2_ARGS_CTOR = null;
}
}
protected static class CallableStatementParam {
int desiredJdbcType;
int index;
int inOutModifier;
boolean isIn;
boolean isOut;
int jdbcType;
short nullability;
String paramName;
int precision;
int scale;
String typeName;
CallableStatementParam(String name, int idx, boolean in, boolean out,
int jdbcType, String typeName, int precision, int scale,
short nullability, int inOutModifier) {
this.paramName = name;
this.isIn = in;
this.isOut = out;
this.index = idx;
this.jdbcType = jdbcType;
this.typeName = typeName;
this.precision = precision;
this.scale = scale;
this.nullability = nullability;
this.inOutModifier = inOutModifier;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#clone()
*/
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
protected class CallableStatementParamInfo {
String catalogInUse;
boolean isFunctionCall;
String nativeSql;
int numParameters;
List<CallableStatementParam> parameterList;
Map<String, CallableStatementParam> parameterMap;
/**
* synchronized externally in checkReadOnlyProcedure()
*/
boolean isReadOnlySafeProcedure = false;
/**
* synchronized externally in checkReadOnlyProcedure()
*/
boolean isReadOnlySafeChecked = false;
/**
* Constructor that converts a full list of parameter metadata into one
* that only represents the placeholders present in the {CALL ()}.
*
* @param fullParamInfo the metadata for all parameters for this stored
* procedure or function.
*/
CallableStatementParamInfo(CallableStatementParamInfo fullParamInfo) {
this.nativeSql = originalSql;
this.catalogInUse = currentCatalog;
isFunctionCall = fullParamInfo.isFunctionCall;
@SuppressWarnings("synthetic-access")
int[] localParameterMap = placeholderToParameterIndexMap;
int parameterMapLength = localParameterMap.length;
this.isReadOnlySafeProcedure = fullParamInfo.isReadOnlySafeProcedure;
this.isReadOnlySafeChecked = fullParamInfo.isReadOnlySafeChecked;
parameterList = new ArrayList<CallableStatementParam>(fullParamInfo.numParameters);
parameterMap = new HashMap<String, CallableStatementParam>(fullParamInfo.numParameters);
if (isFunctionCall) {
// Take the return value
parameterList.add(fullParamInfo.parameterList.get(0));
}
int offset = isFunctionCall ? 1 : 0;
for (int i = 0; i < parameterMapLength; i++) {
if (localParameterMap[i] != 0) {
CallableStatementParam param = fullParamInfo.parameterList.get(localParameterMap[i] + offset);
parameterList.add(param);
parameterMap.put(param.paramName, param);
}
}
this.numParameters = parameterList.size();
}
@SuppressWarnings("synthetic-access")
CallableStatementParamInfo(java.sql.ResultSet paramTypesRs)
throws SQLException {
boolean hadRows = paramTypesRs.last();
this.nativeSql = originalSql;
this.catalogInUse = currentCatalog;
isFunctionCall = callingStoredFunction;
if (hadRows) {
this.numParameters = paramTypesRs.getRow();
this.parameterList = new ArrayList<CallableStatementParam>(this.numParameters);
this.parameterMap = new HashMap<String, CallableStatementParam>(this.numParameters);
paramTypesRs.beforeFirst();
addParametersFromDBMD(paramTypesRs);
} else {
this.numParameters = 0;
}
if (isFunctionCall) {
this.numParameters += 1;
}
}
private void addParametersFromDBMD(java.sql.ResultSet paramTypesRs)
throws SQLException {
int i = 0;
while (paramTypesRs.next()) {
String paramName = paramTypesRs.getString(4);
int inOutModifier = paramTypesRs.getInt(5);
boolean isOutParameter = false;
boolean isInParameter = false;
if (i == 0 && isFunctionCall) {
isOutParameter = true;
isInParameter = false;
} else if (inOutModifier == DatabaseMetaData.procedureColumnInOut) {
isOutParameter = true;
isInParameter = true;
} else if (inOutModifier == DatabaseMetaData.procedureColumnIn) {
isOutParameter = false;
isInParameter = true;
} else if (inOutModifier == DatabaseMetaData.procedureColumnOut) {
isOutParameter = true;
isInParameter = false;
}
int jdbcType = paramTypesRs.getInt(6);
String typeName = paramTypesRs.getString(7);
int precision = paramTypesRs.getInt(8);
int scale = paramTypesRs.getInt(10);
short nullability = paramTypesRs.getShort(12);
CallableStatementParam paramInfoToAdd = new CallableStatementParam(
paramName, i++, isInParameter, isOutParameter,
jdbcType, typeName, precision, scale, nullability,
inOutModifier);
this.parameterList.add(paramInfoToAdd);
this.parameterMap.put(paramName, paramInfoToAdd);
}
}
protected void checkBounds(int paramIndex) throws SQLException {
int localParamIndex = paramIndex - 1;
if ((paramIndex < 0) || (localParamIndex >= this.numParameters)) {
throw SQLError.createSQLException(
Messages.getString("CallableStatement.11") + paramIndex //$NON-NLS-1$
+ Messages.getString("CallableStatement.12") + numParameters //$NON-NLS-1$
+ Messages.getString("CallableStatement.13"), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor()); //$NON-NLS-1$
}
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#clone()
*/
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
CallableStatementParam getParameter(int index) {
return this.parameterList.get(index);
}
CallableStatementParam getParameter(String name) {
return this.parameterMap.get(name);
}
public String getParameterClassName(int arg0) throws SQLException {
String mysqlTypeName = getParameterTypeName(arg0);
boolean isBinaryOrBlob = StringUtils.indexOfIgnoreCase(mysqlTypeName, "BLOB") != -1 ||
StringUtils.indexOfIgnoreCase(mysqlTypeName, "BINARY") != -1;
boolean isUnsigned = StringUtils.indexOfIgnoreCase(mysqlTypeName, "UNSIGNED") != -1;
int mysqlTypeIfKnown = 0;
if (StringUtils.startsWithIgnoreCase(mysqlTypeName, "MEDIUMINT")) {
mysqlTypeIfKnown = MysqlDefs.FIELD_TYPE_INT24;
}
return ResultSetMetaData.getClassNameForJavaType(getParameterType(arg0),
isUnsigned, mysqlTypeIfKnown, isBinaryOrBlob, false);
}
public int getParameterCount() throws SQLException {
if (this.parameterList == null) {
return 0;
}
return this.parameterList.size();
}
public int getParameterMode(int arg0) throws SQLException {
checkBounds(arg0);
return getParameter(arg0 - 1).inOutModifier;
}
public int getParameterType(int arg0) throws SQLException {
checkBounds(arg0);
return getParameter(arg0 - 1).jdbcType;
}
public String getParameterTypeName(int arg0) throws SQLException {
checkBounds(arg0);
return getParameter(arg0 - 1).typeName;
}
public int getPrecision(int arg0) throws SQLException {
checkBounds(arg0);
return getParameter(arg0 - 1).precision;
}
public int getScale(int arg0) throws SQLException {
checkBounds(arg0);
return getParameter(arg0 - 1).scale;
}
public int isNullable(int arg0) throws SQLException {
checkBounds(arg0);
return getParameter(arg0 - 1).nullability;
}
public boolean isSigned(int arg0) throws SQLException {
checkBounds(arg0);
return false;
}
Iterator<CallableStatementParam> iterator() {
return this.parameterList.iterator();
}
int numberOfParameters() {
return this.numParameters;
}
}
/**
* Can't implement this directly, as then you can't use callable statements
* on JDK-1.3.1, which unfortunately isn't EOL'd yet, and still present
* quite a bit out there in the wild (Websphere, FreeBSD, anyone?)
*/
protected class CallableStatementParamInfoJDBC3 extends CallableStatementParamInfo
implements ParameterMetaData {
CallableStatementParamInfoJDBC3(java.sql.ResultSet paramTypesRs)
throws SQLException {
super(paramTypesRs);
}
public CallableStatementParamInfoJDBC3(CallableStatementParamInfo paramInfo) {
super(paramInfo);
}
/**
* Returns true if this either implements the interface argument or is directly or indirectly a wrapper
* for an object that does. Returns false otherwise. If this implements the interface then return true,
* else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped
* object. If this does not implement the interface and is not a wrapper, return false.
* This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that
* callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method
* returns true then calling <code>unwrap</code> with the same argument should succeed.
*
* @param interfaces a Class defining an interface.
* @return true if this implements the interface or directly or indirectly wraps an object that does.
* @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
* for an object with the given interface.
* @since 1.6
*/
public boolean isWrapperFor(Class<?> iface) throws SQLException {
checkClosed();
// This works for classes that aren't actually wrapping
// anything
return iface.isInstance(this);
}
/**
* Returns an object that implements the given interface to allow access to non-standard methods,
* or standard methods not exposed by the proxy.
* The result may be either the object found to implement the interface or a proxy for that object.
* If the receiver implements the interface then that is the object. If the receiver is a wrapper
* and the wrapped object implements the interface then that is the object. Otherwise the object is
* the result of calling <code>unwrap</code> recursively on the wrapped object. If the receiver is not a
* wrapper and does not implement the interface, then an <code>SQLException</code> is thrown.
*
* @param iface A Class defining an interface that the result must implement.
* @return an object that implements the interface. May be a proxy for the actual implementing object.
* @throws java.sql.SQLException If no object found that implements the interface
* @since 1.6
*/
public Object unwrap(Class<?> iface) throws java.sql.SQLException {
try {
// This works for classes that aren't actually wrapping
// anything
return Util.cast(iface, this);
} catch (ClassCastException cce) {
throw SQLError.createSQLException("Unable to unwrap to " + iface.toString(),
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
}
}
private final static int NOT_OUTPUT_PARAMETER_INDICATOR = Integer.MIN_VALUE;
private final static String PARAMETER_NAMESPACE_PREFIX = "@com_mysql_jdbc_outparam_"; //$NON-NLS-1$
private static String mangleParameterName(String origParameterName) {
//Fixed for 5.5+ in callers
if (origParameterName == null) {
return null;
}
int offset = 0;
if (origParameterName.length() > 0
&& origParameterName.charAt(0) == '@') {
offset = 1;
}
StringBuffer paramNameBuf = new StringBuffer(PARAMETER_NAMESPACE_PREFIX
.length()
+ origParameterName.length());
paramNameBuf.append(PARAMETER_NAMESPACE_PREFIX);
paramNameBuf.append(origParameterName.substring(offset));
return paramNameBuf.toString();
}
private boolean callingStoredFunction = false;
private ResultSetInternalMethods functionReturnValueResults;
private boolean hasOutputParams = false;
// private List parameterList;
// private Map parameterMap;
private ResultSetInternalMethods outputParameterResults;
protected boolean outputParamWasNull = false;
private int[] parameterIndexToRsIndex;
protected CallableStatementParamInfo paramInfo;
private CallableStatementParam returnValueParam;
/**
* Creates a new CallableStatement
*
* @param conn
* the connection creating this statement
* @param paramInfo
* the SQL to prepare
*
* @throws SQLException
* if an error occurs
*/
public CallableStatement(MySQLConnection conn,
CallableStatementParamInfo paramInfo) throws SQLException {
super(conn, paramInfo.nativeSql, paramInfo.catalogInUse);
this.paramInfo = paramInfo;
this.callingStoredFunction = this.paramInfo.isFunctionCall;
if (this.callingStoredFunction) {
this.parameterCount += 1;
}
this.retrieveGeneratedKeys = true; // not provided for in the JDBC spec
}
/**
* Creates a callable statement instance -- We need to provide factory-style methods
* so we can support both JDBC3 (and older) and JDBC4 runtimes, otherwise
* the class verifier complains when it tries to load JDBC4-only interface
* classes that are present in JDBC4 method signatures.
*/
protected static CallableStatement getInstance(MySQLConnection conn, String sql,
String catalog, boolean isFunctionCall) throws SQLException {
if (!Util.isJdbc4()) {
return new CallableStatement(conn, sql, catalog, isFunctionCall);
}
return (CallableStatement) Util.handleNewInstance(
JDBC_4_CSTMT_4_ARGS_CTOR, new Object[] { conn, sql, catalog,
Boolean.valueOf(isFunctionCall) }, conn.getExceptionInterceptor());
}
/**
* Creates a callable statement instance -- We need to provide factory-style methods
* so we can support both JDBC3 (and older) and JDBC4 runtimes, otherwise
* the class verifier complains when it tries to load JDBC4-only interface
* classes that are present in JDBC4 method signatures.
*/
protected static CallableStatement getInstance(MySQLConnection conn,
CallableStatementParamInfo paramInfo) throws SQLException {
if (!Util.isJdbc4()) {
return new CallableStatement(conn, paramInfo);
}
return (CallableStatement) Util.handleNewInstance(
JDBC_4_CSTMT_2_ARGS_CTOR, new Object[] { conn, paramInfo }, conn.getExceptionInterceptor());
}
private int[] placeholderToParameterIndexMap;
private void generateParameterMap() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.paramInfo == null) {
return;
}
// if the user specified some parameters as literals, we need to
// provide a map from the specified placeholders to the actual
// parameter numbers
int parameterCountFromMetaData = this.paramInfo.getParameterCount();
// Ignore the first ? if this is a stored function, it doesn't count
if (this.callingStoredFunction) {
parameterCountFromMetaData--;
}
if (this.paramInfo != null &&
this.parameterCount != parameterCountFromMetaData) {
this.placeholderToParameterIndexMap = new int[this.parameterCount];
int startPos = this.callingStoredFunction ? StringUtils.indexOfIgnoreCase(this.originalSql,
"SELECT") : StringUtils.indexOfIgnoreCase(this.originalSql, "CALL");
if (startPos != -1) {
int parenOpenPos = this.originalSql.indexOf('(', startPos + 4);
if (parenOpenPos != -1) {
int parenClosePos = StringUtils.indexOfIgnoreCaseRespectQuotes(parenOpenPos,
this.originalSql, ")", '\'', true);
if (parenClosePos != -1) {
List<?> parsedParameters = StringUtils.split(this.originalSql.substring(parenOpenPos + 1, parenClosePos), ",", "'\"", "'\"", true);
int numParsedParameters = parsedParameters.size();
// sanity check
if (numParsedParameters != this.parameterCount) {
// bail?
}
int placeholderCount = 0;
for (int i = 0; i < numParsedParameters; i++) {
if (((String)parsedParameters.get(i)).equals("?")) {
this.placeholderToParameterIndexMap[placeholderCount++] = i;
}
}
}
}
}
}
}
}
/**
* Creates a new CallableStatement
*
* @param conn
* the connection creating this statement
* @param sql
* the SQL to prepare
* @param catalog
* the current catalog
*
* @throws SQLException
* if an error occurs
*/
public CallableStatement(MySQLConnection conn, String sql, String catalog,
boolean isFunctionCall) throws SQLException {
super(conn, sql, catalog);
this.callingStoredFunction = isFunctionCall;
if (!this.callingStoredFunction) {
if (!StringUtils.startsWithIgnoreCaseAndWs(sql, "CALL")) {
// not really a stored procedure call
fakeParameterTypes(false);
} else {
determineParameterTypes();
}
generateParameterMap();
} else {
determineParameterTypes();
generateParameterMap();
this.parameterCount += 1;
}
this.retrieveGeneratedKeys = true; // not provided for in the JDBC spec
}
/*
* (non-Javadoc)
*
* @see java.sql.PreparedStatement#addBatch()
*/
public void addBatch() throws SQLException {
setOutParams();
super.addBatch();
}
private CallableStatementParam checkIsOutputParam(int paramIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.callingStoredFunction) {
if (paramIndex == 1) {
if (this.returnValueParam == null) {
this.returnValueParam = new CallableStatementParam("", 0,
false, true, Types.VARCHAR, "VARCHAR", 0, 0,
DatabaseMetaData.attributeNullableUnknown,
DatabaseMetaData.procedureColumnReturn);
}
return this.returnValueParam;
}
// Move to position in output result set
paramIndex--;
}
checkParameterIndexBounds(paramIndex);
int localParamIndex = paramIndex - 1;
if (this.placeholderToParameterIndexMap != null) {
localParamIndex = this.placeholderToParameterIndexMap[localParamIndex];
}
CallableStatementParam paramDescriptor = this.paramInfo
.getParameter(localParamIndex);
// We don't have reliable metadata in this case, trust
// the caller
if (this.connection.getNoAccessToProcedureBodies()) {
paramDescriptor.isOut = true;
paramDescriptor.isIn = true;
paramDescriptor.inOutModifier = DatabaseMetaData.procedureColumnInOut;
} else if (!paramDescriptor.isOut) {
throw SQLError.createSQLException(
Messages.getString("CallableStatement.9") + paramIndex //$NON-NLS-1$
+ Messages.getString("CallableStatement.10"), //$NON-NLS-1$
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
this.hasOutputParams = true;
return paramDescriptor;
}
}
/**
* DOCUMENT ME!
*
* @param paramIndex
*
* @throws SQLException
*/
private void checkParameterIndexBounds(int paramIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
this.paramInfo.checkBounds(paramIndex);
}
}
/**
* Checks whether or not this statement is supposed to be providing
* streamable result sets...If output parameters are registered, the driver
* can not stream the results.
*
* @throws SQLException
* DOCUMENT ME!
*/
private void checkStreamability() throws SQLException {
if (this.hasOutputParams && createStreamingResultSet()) {
throw SQLError.createSQLException(Messages.getString("CallableStatement.14"), //$NON-NLS-1$
SQLError.SQL_STATE_DRIVER_NOT_CAPABLE, getExceptionInterceptor());
}
}
public void clearParameters() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
super.clearParameters();
try {
if (this.outputParameterResults != null) {
this.outputParameterResults.close();
}
} finally {
this.outputParameterResults = null;
}
}
}
/**
* Used to fake up some metadata when we don't have access to
* SHOW CREATE PROCEDURE or mysql.proc.
*
* @throws SQLException if we can't build the metadata.
*/
private void fakeParameterTypes(boolean isReallyProcedure) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
Field[] fields = new Field[13];
fields[0] = new Field("", "PROCEDURE_CAT", Types.CHAR, 0);
fields[1] = new Field("", "PROCEDURE_SCHEM", Types.CHAR, 0);
fields[2] = new Field("", "PROCEDURE_NAME", Types.CHAR, 0);
fields[3] = new Field("", "COLUMN_NAME", Types.CHAR, 0);
fields[4] = new Field("", "COLUMN_TYPE", Types.CHAR, 0);
fields[5] = new Field("", "DATA_TYPE", Types.SMALLINT, 0);
fields[6] = new Field("", "TYPE_NAME", Types.CHAR, 0);
fields[7] = new Field("", "PRECISION", Types.INTEGER, 0);
fields[8] = new Field("", "LENGTH", Types.INTEGER, 0);
fields[9] = new Field("", "SCALE", Types.SMALLINT, 0);
fields[10] = new Field("", "RADIX", Types.SMALLINT, 0);
fields[11] = new Field("", "NULLABLE", Types.SMALLINT, 0);
fields[12] = new Field("", "REMARKS", Types.CHAR, 0);
String procName = isReallyProcedure ? extractProcedureName() : null;
byte[] procNameAsBytes = null;
try {
procNameAsBytes = procName == null ? null : StringUtils.getBytes(procName, "UTF-8");
} catch (UnsupportedEncodingException ueEx) {
procNameAsBytes = StringUtils.s2b(procName, this.connection);
}
ArrayList<ResultSetRow> resultRows = new ArrayList<ResultSetRow>();
for (int i = 0; i < this.parameterCount; i++) {
byte[][] row = new byte[13][];
row[0] = null; // PROCEDURE_CAT
row[1] = null; // PROCEDURE_SCHEM
row[2] = procNameAsBytes; // PROCEDURE/NAME
row[3] = StringUtils.s2b(String.valueOf(i), this.connection); // COLUMN_NAME
row[4] = StringUtils.s2b(String
.valueOf(DatabaseMetaData.procedureColumnIn),
this.connection);
row[5] = StringUtils.s2b(String.valueOf(Types.VARCHAR),
this.connection); // DATA_TYPE
row[6] = StringUtils.s2b("VARCHAR", this.connection); // TYPE_NAME
row[7] = StringUtils.s2b(Integer.toString(65535), this.connection); // PRECISION
row[8] = StringUtils.s2b(Integer.toString(65535), this.connection); // LENGTH
row[9] = StringUtils.s2b(Integer.toString(0), this.connection); // SCALE
row[10] = StringUtils.s2b(Integer.toString(10), this.connection); // RADIX
row[11] = StringUtils.s2b(Integer
.toString(DatabaseMetaData.procedureNullableUnknown),
this.connection); // nullable
row[12] = null;
resultRows.add(new ByteArrayRow(row, getExceptionInterceptor()));
}
java.sql.ResultSet paramTypesRs = DatabaseMetaData.buildResultSet(
fields, resultRows, this.connection);
convertGetProcedureColumnsToInternalDescriptors(paramTypesRs);
}
}
private void determineParameterTypes() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
java.sql.ResultSet paramTypesRs = null;
try {
//Bug#57022, we need to check for db.SPname notation first
// and pass on only SPname
String procName = extractProcedureName();
String quotedId = "";
try {
quotedId = this.connection.supportsQuotedIdentifiers() ?
this.connection.getMetaData().getIdentifierQuoteString() : "";
} catch (SQLException sqlEx) {
// Forced by API, never thrown from getIdentifierQuoteString() in
// this implementation.
AssertionFailedException.shouldNotHappen(sqlEx);
}
List<?> parseList = StringUtils.splitDBdotName(procName, "",
quotedId , this.connection.isNoBackslashEscapesSet());
String tmpCatalog = "";
//There *should* be 2 rows, if any.
if (parseList.size() == 2) {
tmpCatalog = (String) parseList.get(0);
procName = (String) parseList.get(1);
} else {
//keep values as they are
}
java.sql.DatabaseMetaData dbmd = this.connection.getMetaData();
boolean useCatalog = false;
if (tmpCatalog.length() <= 0) {
useCatalog = true;
}
paramTypesRs = dbmd.getProcedureColumns(this.connection
.versionMeetsMinimum(5, 0, 2)
&& useCatalog ? this.currentCatalog : tmpCatalog/*null*/, null, procName,
"%"); //$NON-NLS-1$
boolean hasResults = false;
try {
if (paramTypesRs.next()) {
paramTypesRs.previous();
hasResults = true;
}
} catch (Exception e) {
// paramTypesRs is empty, proceed with fake params. swallow, was expected
}
if (hasResults){
convertGetProcedureColumnsToInternalDescriptors(paramTypesRs);
} else {
fakeParameterTypes(true);
}
} finally {
SQLException sqlExRethrow = null;
if (paramTypesRs != null) {
try {
paramTypesRs.close();
} catch (SQLException sqlEx) {
sqlExRethrow = sqlEx;
}
paramTypesRs = null;
}
if (sqlExRethrow != null) {
throw sqlExRethrow;
}
}
}
}
private void convertGetProcedureColumnsToInternalDescriptors(java.sql.ResultSet paramTypesRs) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (!this.connection.isRunningOnJDK13()) {
this.paramInfo = new CallableStatementParamInfoJDBC3(
paramTypesRs);
} else {
this.paramInfo = new CallableStatementParamInfo(paramTypesRs);
}
}
}
/*
* (non-Javadoc)
*
* @see java.sql.PreparedStatement#execute()
*/
public boolean execute() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
boolean returnVal = false;
checkStreamability();
setInOutParamsOnServer();
setOutParams();
returnVal = super.execute();
if (this.callingStoredFunction) {
this.functionReturnValueResults = this.results;
this.functionReturnValueResults.next();
this.results = null;
}
retrieveOutParams();
if (!this.callingStoredFunction) {
return returnVal;
}
// Functions can't return results
return false;
}
}
/*
* (non-Javadoc)
*
* @see java.sql.PreparedStatement#executeQuery()
*/
public java.sql.ResultSet executeQuery() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
checkStreamability();
java.sql.ResultSet execResults = null;
setInOutParamsOnServer();
setOutParams();
execResults = super.executeQuery();
retrieveOutParams();
return execResults;
}
}
/*
* (non-Javadoc)
*
* @see java.sql.PreparedStatement#executeUpdate()
*/
public int executeUpdate() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
int returnVal = -1;
checkStreamability();
if (this.callingStoredFunction) {
execute();
return -1;
}
setInOutParamsOnServer();
setOutParams();
returnVal = super.executeUpdate();
retrieveOutParams();
return returnVal;
}
}
private String extractProcedureName() throws SQLException {
String sanitizedSql = StringUtils.stripComments(this.originalSql,
"`\"'", "`\"'", true, false, true, true);
// TODO: Do this with less memory allocation
int endCallIndex = StringUtils.indexOfIgnoreCase(sanitizedSql,
"CALL "); //$NON-NLS-1$
int offset = 5;
if (endCallIndex == -1) {
endCallIndex = StringUtils.indexOfIgnoreCase(sanitizedSql,
"SELECT ");
offset = 7;
}
if (endCallIndex != -1) {
StringBuffer nameBuf = new StringBuffer();
String trimmedStatement = sanitizedSql.substring(
endCallIndex + offset).trim();
int statementLength = trimmedStatement.length();
for (int i = 0; i < statementLength; i++) {
char c = trimmedStatement.charAt(i);
if (Character.isWhitespace(c) || (c == '(') || (c == '?')) {
break;
}
nameBuf.append(c);
}
return nameBuf.toString();
}
throw SQLError.createSQLException(Messages.getString("CallableStatement.1"), //$NON-NLS-1$
SQLError.SQL_STATE_GENERAL_ERROR, getExceptionInterceptor());
}
/**
* Adds 'at' symbol to beginning of parameter names if needed.
*
* @param paramNameIn
* the parameter name to 'fix'
*
* @return the parameter name with an 'a' prepended, if needed
*
* @throws SQLException
* if the parameter name is null or empty.
*/
protected String fixParameterName(String paramNameIn) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
//Fixed for 5.5+
if (((paramNameIn == null) || (paramNameIn.length() == 0)) && (!hasParametersView())) {
throw SQLError.createSQLException(
((Messages.getString("CallableStatement.0") + paramNameIn) == null) //$NON-NLS-1$
? Messages.getString("CallableStatement.15") : Messages.getString("CallableStatement.16"), SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
getExceptionInterceptor()); //$NON-NLS-1$ //$NON-NLS-2$
}
if ((paramNameIn == null) && (hasParametersView())) {
paramNameIn = "nullpn";
};
if (this.connection.getNoAccessToProcedureBodies()) {
throw SQLError.createSQLException("No access to parameters by name when connection has been configured not to access procedure bodies",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
return mangleParameterName(paramNameIn);
}
}
/**
* @see java.sql.CallableStatement#getArray(int)
*/
public Array getArray(int i) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(i);
Array retValue = rs.getArray(mapOutputParameterIndexToRsIndex(i));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getArray(java.lang.String)
*/
public Array getArray(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Array retValue = rs.getArray(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBigDecimal(int)
*/
public BigDecimal getBigDecimal(int parameterIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
BigDecimal retValue = rs
.getBigDecimal(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* DOCUMENT ME!
*
* @param parameterIndex
* DOCUMENT ME!
* @param scale
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws SQLException
* DOCUMENT ME!
*
* @see java.sql.CallableStatement#getBigDecimal(int, int)
* @deprecated
*/
public BigDecimal getBigDecimal(int parameterIndex, int scale)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
BigDecimal retValue = rs.getBigDecimal(
mapOutputParameterIndexToRsIndex(parameterIndex), scale);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBigDecimal(java.lang.String)
*/
public BigDecimal getBigDecimal(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
BigDecimal retValue = rs.getBigDecimal(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBlob(int)
*/
public Blob getBlob(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Blob retValue = rs
.getBlob(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBlob(java.lang.String)
*/
public Blob getBlob(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Blob retValue = rs.getBlob(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBoolean(int)
*/
public boolean getBoolean(int parameterIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
boolean retValue = rs
.getBoolean(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBoolean(java.lang.String)
*/
public boolean getBoolean(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
boolean retValue = rs.getBoolean(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getByte(int)
*/
public byte getByte(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
byte retValue = rs
.getByte(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getByte(java.lang.String)
*/
public byte getByte(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
byte retValue = rs.getByte(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBytes(int)
*/
public byte[] getBytes(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
byte[] retValue = rs
.getBytes(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getBytes(java.lang.String)
*/
public byte[] getBytes(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
byte[] retValue = rs.getBytes(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getClob(int)
*/
public Clob getClob(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Clob retValue = rs
.getClob(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getClob(java.lang.String)
*/
public Clob getClob(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Clob retValue = rs.getClob(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getDate(int)
*/
public Date getDate(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Date retValue = rs
.getDate(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getDate(int, java.util.Calendar)
*/
public Date getDate(int parameterIndex, Calendar cal)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Date retValue = rs.getDate(
mapOutputParameterIndexToRsIndex(parameterIndex), cal);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getDate(java.lang.String)
*/
public Date getDate(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Date retValue = rs.getDate(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getDate(java.lang.String,
* java.util.Calendar)
*/
public Date getDate(String parameterName, Calendar cal)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Date retValue = rs.getDate(fixParameterName(parameterName), cal);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getDouble(int)
*/
public double getDouble(int parameterIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
double retValue = rs
.getDouble(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getDouble(java.lang.String)
*/
public double getDouble(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
double retValue = rs.getDouble(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getFloat(int)
*/
public float getFloat(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
float retValue = rs
.getFloat(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getFloat(java.lang.String)
*/
public float getFloat(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
float retValue = rs.getFloat(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getInt(int)
*/
public int getInt(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
int retValue = rs
.getInt(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getInt(java.lang.String)
*/
public int getInt(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
int retValue = rs.getInt(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getLong(int)
*/
public long getLong(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
long retValue = rs
.getLong(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getLong(java.lang.String)
*/
public long getLong(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
long retValue = rs.getLong(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
protected int getNamedParamIndex(String paramName, boolean forOut)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.connection.getNoAccessToProcedureBodies()) {
throw SQLError.createSQLException("No access to parameters by name when connection has been configured not to access procedure bodies",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
//Fixed for 5.5+ in callers
if ((paramName == null) || (paramName.length() == 0)) {
throw SQLError.createSQLException(Messages.getString("CallableStatement.2"), //$NON-NLS-1$
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
if (this.paramInfo == null) {
throw SQLError.createSQLException(
Messages.getString("CallableStatement.3") + paramName + Messages.getString("CallableStatement.4"), //$NON-NLS-1$ //$NON-NLS-2$
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
CallableStatementParam namedParamInfo = this.paramInfo
.getParameter(paramName);
if (forOut && !namedParamInfo.isOut) {
throw SQLError.createSQLException(
Messages.getString("CallableStatement.5") + paramName //$NON-NLS-1$
+ Messages.getString("CallableStatement.6"), //$NON-NLS-1$
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
if (this.placeholderToParameterIndexMap == null) {
return namedParamInfo.index + 1; // JDBC indices are 1-based
}
for (int i = 0; i < this.placeholderToParameterIndexMap.length; i++) {
if (this.placeholderToParameterIndexMap[i] == namedParamInfo.index) {
return i + 1;
}
}
throw SQLError.createSQLException("Can't find local placeholder mapping for parameter named \"" +
paramName + "\".", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
}
/**
* @see java.sql.CallableStatement#getObject(int)
*/
public Object getObject(int parameterIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
CallableStatementParam paramDescriptor = checkIsOutputParam(parameterIndex);
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Object retVal = rs.getObjectStoredProc(
mapOutputParameterIndexToRsIndex(parameterIndex),
paramDescriptor.desiredJdbcType);
this.outputParamWasNull = rs.wasNull();
return retVal;
}
}
/**
* @see java.sql.CallableStatement#getObject(int, java.util.Map)
*/
public Object getObject(int parameterIndex, Map<String, Class<?>> map)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Object retVal = rs.getObject(
mapOutputParameterIndexToRsIndex(parameterIndex), map);
this.outputParamWasNull = rs.wasNull();
return retVal;
}
}
/**
* @see java.sql.CallableStatement#getObject(java.lang.String)
*/
public Object getObject(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Object retValue = rs.getObject(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getObject(java.lang.String,
* java.util.Map)
*/
public Object getObject(String parameterName, Map<String, Class<?>> map)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Object retValue = rs.getObject(fixParameterName(parameterName), map);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
// JDBC-4.1
public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
// remove cast once 1.5, 1.6 EOL'd
T retVal = ((ResultSetImpl)rs).getObject(
mapOutputParameterIndexToRsIndex(parameterIndex), type);
this.outputParamWasNull = rs.wasNull();
return retVal;
}
}
public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
T retValue = ((ResultSetImpl)rs).getObject(fixParameterName(parameterName), type);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* Returns the ResultSet that holds the output parameters, or throws an
* appropriate exception if none exist, or they weren't returned.
*
* @return the ResultSet that holds the output parameters
*
* @throws SQLException
* if no output parameters were defined, or if no output
* parameters were returned.
*/
protected ResultSetInternalMethods getOutputParameters(int paramIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
this.outputParamWasNull = false;
if (paramIndex == 1 && this.callingStoredFunction
&& this.returnValueParam != null) {
return this.functionReturnValueResults;
}
if (this.outputParameterResults == null) {
if (this.paramInfo.numberOfParameters() == 0) {
throw SQLError.createSQLException(Messages
.getString("CallableStatement.7"), //$NON-NLS-1$
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
throw SQLError.createSQLException(Messages.getString("CallableStatement.8"), //$NON-NLS-1$
SQLError.SQL_STATE_GENERAL_ERROR, getExceptionInterceptor());
}
return this.outputParameterResults;
}
}
public ParameterMetaData getParameterMetaData()
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.placeholderToParameterIndexMap == null) {
return (CallableStatementParamInfoJDBC3) this.paramInfo;
}
return new CallableStatementParamInfoJDBC3(this.paramInfo);
}
}
/**
* @see java.sql.CallableStatement#getRef(int)
*/
public Ref getRef(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Ref retValue = rs
.getRef(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getRef(java.lang.String)
*/
public Ref getRef(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Ref retValue = rs.getRef(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getShort(int)
*/
public short getShort(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
short retValue = rs
.getShort(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getShort(java.lang.String)
*/
public short getShort(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
short retValue = rs.getShort(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getString(int)
*/
public String getString(int parameterIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
String retValue = rs
.getString(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getString(java.lang.String)
*/
public String getString(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
String retValue = rs.getString(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTime(int)
*/
public Time getTime(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Time retValue = rs
.getTime(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTime(int, java.util.Calendar)
*/
public Time getTime(int parameterIndex, Calendar cal)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Time retValue = rs.getTime(
mapOutputParameterIndexToRsIndex(parameterIndex), cal);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTime(java.lang.String)
*/
public Time getTime(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Time retValue = rs.getTime(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTime(java.lang.String,
* java.util.Calendar)
*/
public Time getTime(String parameterName, Calendar cal)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Time retValue = rs.getTime(fixParameterName(parameterName), cal);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTimestamp(int)
*/
public Timestamp getTimestamp(int parameterIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Timestamp retValue = rs
.getTimestamp(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)
*/
public Timestamp getTimestamp(int parameterIndex, Calendar cal)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
Timestamp retValue = rs.getTimestamp(
mapOutputParameterIndexToRsIndex(parameterIndex), cal);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTimestamp(java.lang.String)
*/
public Timestamp getTimestamp(String parameterName)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Timestamp retValue = rs.getTimestamp(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getTimestamp(java.lang.String,
* java.util.Calendar)
*/
public Timestamp getTimestamp(String parameterName,
Calendar cal) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
Timestamp retValue = rs.getTimestamp(fixParameterName(parameterName),
cal);
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getURL(int)
*/
public URL getURL(int parameterIndex) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(parameterIndex);
URL retValue = rs
.getURL(mapOutputParameterIndexToRsIndex(parameterIndex));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
/**
* @see java.sql.CallableStatement#getURL(java.lang.String)
*/
public URL getURL(String parameterName) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
ResultSetInternalMethods rs = getOutputParameters(0); // definitely not going to be
// from ?=
URL retValue = rs.getURL(fixParameterName(parameterName));
this.outputParamWasNull = rs.wasNull();
return retValue;
}
}
protected int mapOutputParameterIndexToRsIndex(int paramIndex)
throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.returnValueParam != null && paramIndex == 1) {
return 1;
}
checkParameterIndexBounds(paramIndex);
int localParamIndex = paramIndex - 1;
if (this.placeholderToParameterIndexMap != null) {
localParamIndex = this.placeholderToParameterIndexMap[localParamIndex];
}
int rsIndex = this.parameterIndexToRsIndex[localParamIndex];
if (rsIndex == NOT_OUTPUT_PARAMETER_INDICATOR) {
throw SQLError.createSQLException(
Messages.getString("CallableStatement.21") + paramIndex //$NON-NLS-1$
+ Messages.getString("CallableStatement.22"), //$NON-NLS-1$
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
return rsIndex + 1;
}
}
/**
* @see java.sql.CallableStatement#registerOutParameter(int, int)
*/
public void registerOutParameter(int parameterIndex, int sqlType)
throws SQLException {
CallableStatementParam paramDescriptor = checkIsOutputParam(parameterIndex);
paramDescriptor.desiredJdbcType = sqlType;
}
/**
* @see java.sql.CallableStatement#registerOutParameter(int, int, int)
*/
public void registerOutParameter(int parameterIndex, int sqlType, int scale)
throws SQLException {
registerOutParameter(parameterIndex, sqlType);
}
/**
* @see java.sql.CallableStatement#registerOutParameter(int, int,
* java.lang.String)
*/
public void registerOutParameter(int parameterIndex, int sqlType,
String typeName) throws SQLException {
checkIsOutputParam(parameterIndex);
}
/**
* @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
* int)
*/
public void registerOutParameter(String parameterName,
int sqlType) throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
registerOutParameter(getNamedParamIndex(parameterName, true), sqlType);
}
}
/**
* @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
* int, int)
*/
public void registerOutParameter(String parameterName, int sqlType,
int scale) throws SQLException {
registerOutParameter(getNamedParamIndex(parameterName, true), sqlType);
}
/**
* @see java.sql.CallableStatement#registerOutParameter(java.lang.String,
* int, java.lang.String)
*/
public void registerOutParameter(String parameterName, int sqlType,
String typeName) throws SQLException {
registerOutParameter(getNamedParamIndex(parameterName, true), sqlType,
typeName);
}
/**
* Issues a second query to retrieve all output parameters.
*
* @throws SQLException
* if an error occurs.
*/
private void retrieveOutParams() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
int numParameters = this.paramInfo.numberOfParameters();
this.parameterIndexToRsIndex = new int[numParameters];
for (int i = 0; i < numParameters; i++) {
this.parameterIndexToRsIndex[i] = NOT_OUTPUT_PARAMETER_INDICATOR;
}
int localParamIndex = 0;
if (numParameters > 0) {
StringBuffer outParameterQuery = new StringBuffer("SELECT "); //$NON-NLS-1$
boolean firstParam = true;
boolean hadOutputParams = false;
for (Iterator<CallableStatementParam> paramIter = this.paramInfo.iterator(); paramIter
.hasNext();) {
CallableStatementParam retrParamInfo = paramIter
.next();
if (retrParamInfo.isOut) {
hadOutputParams = true;
this.parameterIndexToRsIndex[retrParamInfo.index] = localParamIndex++;
if ((retrParamInfo.paramName == null) && (hasParametersView())) {
retrParamInfo.paramName = "nullnp" + retrParamInfo.index;
}
String outParameterName = mangleParameterName(retrParamInfo.paramName);
if (!firstParam) {
outParameterQuery.append(","); //$NON-NLS-1$
} else {
firstParam = false;
}
if (!outParameterName.startsWith("@")) { //$NON-NLS-1$
outParameterQuery.append('@');
}
outParameterQuery.append(outParameterName);
}
}
if (hadOutputParams) {
// We can't use 'ourself' to execute this query, or any
// pending result sets would be overwritten
java.sql.Statement outParameterStmt = null;
java.sql.ResultSet outParamRs = null;
try {
outParameterStmt = this.connection.createStatement();
outParamRs = outParameterStmt
.executeQuery(outParameterQuery.toString());
this.outputParameterResults = ((com.mysql.jdbc.ResultSetInternalMethods) outParamRs)
.copy();
if (!this.outputParameterResults.next()) {
this.outputParameterResults.close();
this.outputParameterResults = null;
}
} finally {
if (outParameterStmt != null) {
outParameterStmt.close();
}
}
} else {
this.outputParameterResults = null;
}
} else {
this.outputParameterResults = null;
}
}
}
/**
* @see java.sql.CallableStatement#setAsciiStream(java.lang.String,
* java.io.InputStream, int)
*/
public void setAsciiStream(String parameterName, InputStream x, int length)
throws SQLException {
setAsciiStream(getNamedParamIndex(parameterName, false), x, length);
}
/**
* @see java.sql.CallableStatement#setBigDecimal(java.lang.String,
* java.math.BigDecimal)
*/
public void setBigDecimal(String parameterName, BigDecimal x)
throws SQLException {
setBigDecimal(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setBinaryStream(java.lang.String,
* java.io.InputStream, int)
*/
public void setBinaryStream(String parameterName, InputStream x, int length)
throws SQLException {
setBinaryStream(getNamedParamIndex(parameterName, false), x, length);
}
/**
* @see java.sql.CallableStatement#setBoolean(java.lang.String, boolean)
*/
public void setBoolean(String parameterName, boolean x) throws SQLException {
setBoolean(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setByte(java.lang.String, byte)
*/
public void setByte(String parameterName, byte x) throws SQLException {
setByte(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setBytes(java.lang.String, byte[])
*/
public void setBytes(String parameterName, byte[] x) throws SQLException {
setBytes(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setCharacterStream(java.lang.String,
* java.io.Reader, int)
*/
public void setCharacterStream(String parameterName, Reader reader,
int length) throws SQLException {
setCharacterStream(getNamedParamIndex(parameterName, false), reader,
length);
}
/**
* @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)
*/
public void setDate(String parameterName, Date x) throws SQLException {
setDate(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date,
* java.util.Calendar)
*/
public void setDate(String parameterName, Date x, Calendar cal)
throws SQLException {
setDate(getNamedParamIndex(parameterName, false), x, cal);
}
/**
* @see java.sql.CallableStatement#setDouble(java.lang.String, double)
*/
public void setDouble(String parameterName, double x) throws SQLException {
setDouble(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setFloat(java.lang.String, float)
*/
public void setFloat(String parameterName, float x) throws SQLException {
setFloat(getNamedParamIndex(parameterName, false), x);
}
/**
*
*/
private void setInOutParamsOnServer() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.paramInfo.numParameters > 0) {
for (Iterator<CallableStatementParam> paramIter = this.paramInfo.iterator(); paramIter
.hasNext();) {
CallableStatementParam inParamInfo = paramIter
.next();
//Fix for 5.5+
if (inParamInfo.isOut && inParamInfo.isIn) {
if ((inParamInfo.paramName == null) && (hasParametersView())) {
inParamInfo.paramName = "nullnp" + inParamInfo.index;
};
String inOutParameterName = mangleParameterName(inParamInfo.paramName);
StringBuffer queryBuf = new StringBuffer(
4 + inOutParameterName.length() + 1 + 1);
queryBuf.append("SET "); //$NON-NLS-1$
queryBuf.append(inOutParameterName);
queryBuf.append("=?"); //$NON-NLS-1$
PreparedStatement setPstmt = null;
try {
setPstmt = (PreparedStatement) this.connection
.clientPrepareStatement(queryBuf.toString());
if (this.isNull[inParamInfo.index]) {
setPstmt.setBytesNoEscapeNoQuotes(1, "NULL".getBytes());
} else {
byte[] parameterAsBytes = getBytesRepresentation(
inParamInfo.index);
if (parameterAsBytes != null) {
if (parameterAsBytes.length > 8
&& parameterAsBytes[0] == '_'
&& parameterAsBytes[1] == 'b'
&& parameterAsBytes[2] == 'i'
&& parameterAsBytes[3] == 'n'
&& parameterAsBytes[4] == 'a'
&& parameterAsBytes[5] == 'r'
&& parameterAsBytes[6] == 'y'
&& parameterAsBytes[7] == '\'') {
setPstmt.setBytesNoEscapeNoQuotes(1,
parameterAsBytes);
} else {
int sqlType = inParamInfo.desiredJdbcType;
switch (sqlType) {
case Types.BIT:
case Types.BINARY:
case Types.BLOB:
case Types.JAVA_OBJECT:
case Types.LONGVARBINARY:
case Types.VARBINARY:
setPstmt.setBytes(1, parameterAsBytes);
break;
default:
// the inherited PreparedStatement methods
// have already escaped and quoted these parameters
setPstmt.setBytesNoEscape(1, parameterAsBytes);
}
}
} else {
setPstmt.setNull(1, Types.NULL);
}
}
setPstmt.executeUpdate();
} finally {
if (setPstmt != null) {
setPstmt.close();
}
}
}
}
}
}
}
/**
* @see java.sql.CallableStatement#setInt(java.lang.String, int)
*/
public void setInt(String parameterName, int x) throws SQLException {
setInt(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setLong(java.lang.String, long)
*/
public void setLong(String parameterName, long x) throws SQLException {
setLong(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setNull(java.lang.String, int)
*/
public void setNull(String parameterName, int sqlType) throws SQLException {
setNull(getNamedParamIndex(parameterName, false), sqlType);
}
/**
* @see java.sql.CallableStatement#setNull(java.lang.String, int,
* java.lang.String)
*/
public void setNull(String parameterName, int sqlType, String typeName)
throws SQLException {
setNull(getNamedParamIndex(parameterName, false), sqlType, typeName);
}
/**
* @see java.sql.CallableStatement#setObject(java.lang.String,
* java.lang.Object)
*/
public void setObject(String parameterName, Object x) throws SQLException {
setObject(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setObject(java.lang.String,
* java.lang.Object, int)
*/
public void setObject(String parameterName, Object x, int targetSqlType)
throws SQLException {
setObject(getNamedParamIndex(parameterName, false), x, targetSqlType);
}
/**
* @see java.sql.CallableStatement#setObject(java.lang.String,
* java.lang.Object, int, int)
*/
public void setObject(String parameterName, Object x, int targetSqlType,
int scale) throws SQLException {
}
private void setOutParams() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.paramInfo.numParameters > 0) {
for (Iterator<CallableStatementParam> paramIter = this.paramInfo.iterator(); paramIter
.hasNext();) {
CallableStatementParam outParamInfo = paramIter
.next();
if (!this.callingStoredFunction && outParamInfo.isOut) {
if ((outParamInfo.paramName == null) && (hasParametersView())) {
outParamInfo.paramName = "nullnp" + outParamInfo.index;
};
String outParameterName = mangleParameterName(outParamInfo.paramName);
int outParamIndex = 0;
if (this.placeholderToParameterIndexMap == null) {
outParamIndex = outParamInfo.index + 1;
} else {
// Find it, todo: remove this linear search
boolean found = false;
for (int i = 0; i < this.placeholderToParameterIndexMap.length; i++) {
if (this.placeholderToParameterIndexMap[i] == outParamInfo.index) {
outParamIndex = i + 1; /* JDBC is 1-based */
found = true;
break;
}
}
if (!found) {
throw SQLError.createSQLException("boo!", "S1000", this.connection.getExceptionInterceptor());
}
}
this.setBytesNoEscapeNoQuotes(outParamIndex,
StringUtils.getBytes(outParameterName,
this.charConverter, this.charEncoding,
this.connection
.getServerCharacterEncoding(),
this.connection.parserKnowsUnicode(), getExceptionInterceptor()));
}
}
}
}
}
/**
* @see java.sql.CallableStatement#setShort(java.lang.String, short)
*/
public void setShort(String parameterName, short x) throws SQLException {
setShort(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setString(java.lang.String,
* java.lang.String)
*/
public void setString(String parameterName, String x) throws SQLException {
setString(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)
*/
public void setTime(String parameterName, Time x) throws SQLException {
setTime(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time,
* java.util.Calendar)
*/
public void setTime(String parameterName, Time x, Calendar cal)
throws SQLException {
setTime(getNamedParamIndex(parameterName, false), x, cal);
}
/**
* @see java.sql.CallableStatement#setTimestamp(java.lang.String,
* java.sql.Timestamp)
*/
public void setTimestamp(String parameterName, Timestamp x)
throws SQLException {
setTimestamp(getNamedParamIndex(parameterName, false), x);
}
/**
* @see java.sql.CallableStatement#setTimestamp(java.lang.String,
* java.sql.Timestamp, java.util.Calendar)
*/
public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
throws SQLException {
setTimestamp(getNamedParamIndex(parameterName, false), x, cal);
}
/**
* @see java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)
*/
public void setURL(String parameterName, URL val) throws SQLException {
setURL(getNamedParamIndex(parameterName, false), val);
}
/**
* @see java.sql.CallableStatement#wasNull()
*/
public boolean wasNull() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
return this.outputParamWasNull;
}
}
public int[] executeBatch() throws SQLException {
if (this.hasOutputParams) {
throw SQLError.createSQLException("Can't call executeBatch() on CallableStatement with OUTPUT parameters",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
return super.executeBatch();
}
protected int getParameterIndexOffset() {
if (this.callingStoredFunction) {
return -1;
}
return super.getParameterIndexOffset();
}
public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
setAsciiStream(getNamedParamIndex(parameterName, false), x);
}
public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
setAsciiStream(getNamedParamIndex(parameterName, false), x, length);
}
public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
setBinaryStream(getNamedParamIndex(parameterName, false), x);
}
public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
setBinaryStream(getNamedParamIndex(parameterName, false), x, length);
}
public void setBlob(String parameterName, Blob x) throws SQLException {
setBlob(getNamedParamIndex(parameterName, false), x);
}
public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
setBlob(getNamedParamIndex(parameterName, false), inputStream);
}
public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
setBlob(getNamedParamIndex(parameterName, false), inputStream, length);
}
public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
setCharacterStream(getNamedParamIndex(parameterName, false), reader);
}
public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
setCharacterStream(getNamedParamIndex(parameterName, false), reader, length);
}
public void setClob(String parameterName, Clob x) throws SQLException {
setClob(getNamedParamIndex(parameterName, false), x);
}
public void setClob(String parameterName, Reader reader) throws SQLException {
setClob(getNamedParamIndex(parameterName, false), reader);
}
public void setClob(String parameterName, Reader reader, long length) throws SQLException {
setClob(getNamedParamIndex(parameterName, false), reader, length);
}
public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
setNCharacterStream(getNamedParamIndex(parameterName, false), value);
}
public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
setNCharacterStream(getNamedParamIndex(parameterName, false), value, length);
}
/**
* Check whether the stored procedure alters any data or is safe for read-only usage.
*
* @return true if procedure does not alter data
* @throws SQLException
*/
private boolean checkReadOnlyProcedure() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
if (this.connection.getNoAccessToProcedureBodies()) {
return false;
}
if (this.paramInfo.isReadOnlySafeChecked) {
return this.paramInfo.isReadOnlySafeProcedure;
}
ResultSet rs = null;
java.sql.PreparedStatement ps = null;
try {
String procName = extractProcedureName();
String catalog = this.currentCatalog;
if (procName.indexOf(".") != -1) {
catalog = procName.substring(0, procName.indexOf("."));
if (StringUtils.startsWithIgnoreCaseAndWs(catalog, "`") && catalog.trim().endsWith("`")) {
catalog = catalog.substring(1, catalog.length() - 1);
}
procName = procName.substring(procName.indexOf(".") + 1);
procName = StringUtils.toString(StringUtils.stripEnclosure(
StringUtils.getBytes(procName), "`", "`"));
}
ps = this.connection
.prepareStatement("SELECT SQL_DATA_ACCESS FROM "
+ " information_schema.routines "
+ " WHERE routine_schema = ? "
+ " AND routine_name = ?");
ps.setMaxRows(0);
ps.setFetchSize(0);
ps.setString(1, catalog);
ps.setString(2, procName);
rs = ps.executeQuery();
if (rs.next()) {
String sqlDataAccess = rs.getString(1);
if ("READS SQL DATA".equalsIgnoreCase(sqlDataAccess)
|| "NO SQL".equalsIgnoreCase(sqlDataAccess)) {
synchronized (this.paramInfo) {
this.paramInfo.isReadOnlySafeChecked = true;
this.paramInfo.isReadOnlySafeProcedure = true;
}
return true;
}
}
} catch (SQLException e) {
// swallow the Exception
} finally {
if(rs != null){
rs.close();
}
if(ps != null){
ps.close();
}
}
this.paramInfo.isReadOnlySafeChecked = false;
this.paramInfo.isReadOnlySafeProcedure = false;
}
return false;
}
protected boolean checkReadOnlySafeStatement() throws SQLException {
return (super.checkReadOnlySafeStatement() || this.checkReadOnlyProcedure());
}
private boolean hasParametersView() throws SQLException {
synchronized (checkClosed().getConnectionMutex()) {
try {
if (this.connection.versionMeetsMinimum(5, 5, 0)) {
java.sql.DatabaseMetaData dbmd1 = new DatabaseMetaDataUsingInfoSchema(this.connection, this.connection.getCatalog());
return ((DatabaseMetaDataUsingInfoSchema)dbmd1).gethasParametersView();
}
return false;
} catch (SQLException e) {
return false;
}
}
}
}