view src/main/java/org/monetdb/jdbc/MonetCallableStatement.java @ 931:df18aa5c8a61

Add test for MonetDriver.getPropertyInfo(url, props). The implementation is moved to Parameter.java which contains the list of connection parameters. It currently only returns the mandatory connection parameters.
author Martin van Dinther <martin.van.dinther@monetdbsolutions.com>
date Thu, 24 Oct 2024 19:10:06 +0200 (6 months ago)
parents e890195256ac
children d416e9b6b3d0
line wrap: on
line source
/*
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0.  If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Copyright 2024 MonetDB Foundation;
 * Copyright August 2008 - 2023 MonetDB B.V.;
 * Copyright 1997 - July 2008 CWI.
 */

package org.monetdb.jdbc;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLType;	// new as of Java 1.8
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;

/**
 *<pre>
 * A {@link CallableStatement} suitable for the MonetDB database.
 *
 * The interface used to execute SQL stored procedures.
 * The JDBC API provides a stored procedure SQL escape syntax that allows
 * stored procedures to be called in a standard way for all RDBMSs.
 * This escape syntax has one form that includes a result parameter (MonetDB
 * does not support this) and one that does not. If used, the result parameter
 * must be registered as an OUT parameter (MonetDB does not support this).
 * The other parameters can be used for input, output or both.
 * Parameters are referred to sequentially, by number, with the first parameter being 1.
 *  {?= call &lt;procedure-name&gt; [ (&lt;arg1&gt;, &lt;arg2&gt;, ...) ] }
 *  {call &lt;procedure-name&gt; [ (&lt;arg1&gt;, &lt;arg2&gt;, ...) ] }
 *
 * IN parameter values are set using the set methods inherited from PreparedStatement.
 * The type of all OUT parameters must be registered prior to executing the stored procedure;
 * their values are retrieved after execution via the get methods provided here.
 * <b>Note</b>: MonetDB does NOT support OUT or INOUT parameters. Only IN parameters are supported.
 *
 * A CallableStatement can return one ResultSet object or multiple ResultSet objects.
 * Multiple ResultSet objects are handled using operations inherited from Statement.
 *
 * For maximum portability, a call's ResultSet objects and update counts
 * should be processed prior to getting the values of output parameters.
 *
 * This implementation of the CallableStatement interface reuses the
 * implementation of MonetPreparedStatement for preparing the call statement,
 * bind parameter values and execute the call, possibly multiple times with
 * different parameter values.
 *
 * Note: currently we can not implement:
 * - all getXyz(parameterIndex/parameterName, ...) methods
 * - all registerOutParameter(parameterIndex/parameterName, int sqlType, ...) methods
 * - wasNull() method
 * because output parameters in stored procedures are not supported by MonetDB.
 *</pre>
 *
 * @author Martin van Dinther
 * @version 1.2
 */

public final class MonetCallableStatement
	extends MonetPreparedStatement
	implements CallableStatement
{
	/**
	 * MonetCallableStatement constructor which checks the arguments for validity.
	 * A MonetCallableStatement is backed by a {@link MonetPreparedStatement},
	 * which deals with most of the required stuff of this class.
	 *
	 * @param connection the connection that created this Statement
	 * @param resultSetType type of {@link java.sql.ResultSet} to produce
	 * @param resultSetConcurrency concurrency of ResultSet to produce
	 * @param resultSetHoldability holdability of ResultSet to produce
	 * @param callQuery - an SQL CALL statement that may contain one or more '?' parameter placeholders.
	 *	Typically this statement is specified using JDBC call escape syntax:
	 *	{ call &lt;procedure_name&gt; [(?,?, ...)] }
	 *	or
	 *	{ ?= call &lt;procedure_name&gt; [(?,?, ...)] }
	 * @throws SQLException if an error occurs during creation
	 * @throws IllegalArgumentException is one of the arguments is null or empty
	 */
	MonetCallableStatement(
			final MonetConnection connection,
			final int resultSetType,
			final int resultSetConcurrency,
			final int resultSetHoldability,
			final String callQuery)
		throws SQLException, IllegalArgumentException
	{
		super(
			connection,
			resultSetType,
			resultSetConcurrency,
			resultSetHoldability,
			connection.supportsEscapeSequenceSyntax() ? callQuery : removeEscapes(callQuery)
		);
	}

	/**
	 * Parse call query string on
	 *  { [?=] call &lt;procedure-name&gt; [(&lt;arg1&gt;,&lt;arg2&gt;, ...)] }
	 * and remove the JDBC escapes pairs: { and }
	 *
	 * @param query the SQL call statement
	 * @return query without the escape characters: { and }
	 */
	final private static String removeEscapes(final String query) {
		if (query == null)
			return null;

		final int firstAccOpen = query.indexOf('{');
		if (firstAccOpen == -1)
			// nothing to remove
			return query;

		final int len = query.length();
		final StringBuilder buf = new StringBuilder(len);
		int countAccolades = 0;
		// simple scanner which copies all characters except the first '{' and matching '}' character
		// we currently do not check if 'call' appears after the first '{' and before the '}' character
		// we currently also do not deal correctly with { or } appearing as comment or as part of a string value
		for (int i = 0; i < len; i++) {
			char c = query.charAt(i);
			switch (c) {
			case '{':
				countAccolades++;
				if (i == firstAccOpen)
					continue;
				else
					buf.append(c);
				break;
			case '}':
				countAccolades--;
				if (i > firstAccOpen && countAccolades == 0)
					continue;
				else
					buf.append(c);
				break;
			default:
				buf.append(c);
			}
		}
		return buf.toString();
	}

	/**
	 * utility method to convert a parameter name to an int (which represents the parameter index)
	 * this will only succeed for strings like: "1", "2", "3", etc
	 *
	 * @param parameterName the name (a number value) of the parameter
	 * @return the converted index number
	 * @throws SQLException if it cannot convert the string to an integer number
	 */
	final private int nameToIndex(final String parameterName) throws SQLException {
		if (parameterName == null)
			throw new SQLException("Missing parameterName value", "22002");
		try {
			return Integer.parseInt(parameterName);
		} catch (NumberFormatException nfe) {
			throw new SQLException("Cannot convert parameterName '" + parameterName + "' to integer value", "22010");
		}
	}


	// methods of interface CallableStatement

	// all getXyz(parameterIndex/parameterName, ...) methods are NOT supported
	// because output parameters in stored procedures are not supported by MonetDB
	@Override
	public Array getArray(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getArray");
	}
	@Override
	public Array getArray(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getArray");
	}
	@Override
	public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBigDecimal");
	}
	@Override
	@Deprecated
	public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBigDecimal");
	}
	@Override
	public BigDecimal getBigDecimal(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBigDecimal");
	}
	@Override
	public Blob getBlob(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBlob");
	}
	@Override
	public Blob getBlob(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBlob");
	}
	@Override
	public boolean getBoolean(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBoolean");
	}
	@Override
	public boolean getBoolean(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBoolean");
	}
	@Override
	public byte getByte(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getByte");
	}
	@Override
	public byte getByte(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getByte");
	}
	@Override
	public byte[] getBytes(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBytes");
	}
	@Override
	public byte[] getBytes(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getBytes");
	}
	@Override
	public Reader getCharacterStream(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getCharacterStream");
	}
	@Override
	public Reader getCharacterStream(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getCharacterStream");
	}
	@Override
	public Clob getClob(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getClob");
	}
	@Override
	public Clob getClob(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getClob");
	}
	@Override
	public Date getDate(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getDate");
	}
	@Override
	public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
		throw newSQLFeatureNotSupportedException("getDate");
	}
	@Override
	public Date getDate(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getDate");
	}
	@Override
	public Date getDate(String parameterName, Calendar cal) throws SQLException {
		throw newSQLFeatureNotSupportedException("getDate");
	}
	@Override
	public double getDouble(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getDouble");
	}
	@Override
	public double getDouble(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getDouble");
	}
	@Override
	public float getFloat(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getFloat");
	}
	@Override
	public float getFloat(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getFloat");
	}
	@Override
	public int getInt(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getInt");
	}
	@Override
	public int getInt(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getInt");
	}
	@Override
	public long getLong(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getLong");
	}
	@Override
	public long getLong(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getLong");
	}
	@Override
	public Reader getNCharacterStream(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getNCharacterStream");
	}
	@Override
	public Reader getNCharacterStream(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getNCharacterStream");
	}
	@Override
	public NClob getNClob(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getNClob");
	}
	@Override
	public NClob getNClob(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getNClob");
	}
	@Override
	public String getNString(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getNString");
	}
	@Override
	public String getNString(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getNString");
	}
	@Override
	public Object getObject(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getObject");
	}
	@Override
	public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
		throw newSQLFeatureNotSupportedException("getObject");
	}
	@Override
	public Object getObject(int parameterIndex, Map<String,Class<?>> map) throws SQLException {
		throw newSQLFeatureNotSupportedException("getObject");
	}
	@Override
	public Object getObject(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getObject");
	}
	@Override
	public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
		throw newSQLFeatureNotSupportedException("getObject");
	}
	@Override
	public Object getObject(String parameterName, Map<String,Class<?>> map) throws SQLException {
		throw newSQLFeatureNotSupportedException("getObject");
	}
	@Override
	public Ref getRef(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getRef");
	}
	@Override
	public Ref getRef(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getRef");
	}
	@Override
	public RowId getRowId(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getRowId");
	}
	@Override
	public RowId getRowId(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getRowId");
	}
	@Override
	public short getShort(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getShort");
	}
	@Override
	public short getShort(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getShort");
	}
	@Override
	public SQLXML getSQLXML(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getSQLXML");
	}
	@Override
	public SQLXML getSQLXML(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getSQLXML");
	}
	@Override
	public String getString(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getString");
	}
	@Override
	public String getString(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getString");
	}
	@Override
	public Time getTime(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTime");
	}
	@Override
	public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTime");
	}
	@Override
	public Time getTime(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTime");
	}
	@Override
	public Time getTime(String parameterName, Calendar cal) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTime");
	}
	@Override
	public Timestamp getTimestamp(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTimestamp");
	}
	@Override
	public Timestamp getTimestamp(int parameterIndex, Calendar cal) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTimestamp");
	}
	@Override
	public Timestamp getTimestamp(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTimestamp");
	}
	@Override
	public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException {
		throw newSQLFeatureNotSupportedException("getTimestamp");
	}
	@Override
	public URL getURL(int parameterIndex) throws SQLException {
		throw newSQLFeatureNotSupportedException("getURL");
	}
	@Override
	public URL getURL(String parameterName) throws SQLException {
		throw newSQLFeatureNotSupportedException("getURL");
	}


	// all registerOutParameter(parameterIndex/parameterName, int sqlType, ...) methods are NOT supported
	// because output parameters in stored procedures are not supported by MonetDB
	@Override
	public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(int parameterIndex, int sqlType, int scale) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(int parameterIndex, int sqlType, String typeName) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(String parameterName, int sqlType) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}


	// all setXyz(parameterName, ...) methods are mapped to setXyz(nameToIndex(parameterName), ...) methods
	// this only works for parameter names "1", "2", "3", etc.
	@Override
	public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
		setAsciiStream(nameToIndex(parameterName), x);
	}
	@Override
	public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
		setAsciiStream(nameToIndex(parameterName), x, length);
	}
	@Override
	public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException {
		setAsciiStream(nameToIndex(parameterName), x, length);
	}
	@Override
	public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
		setBigDecimal(nameToIndex(parameterName), x);
	}
	@Override
	public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
		setBinaryStream(nameToIndex(parameterName), x);
	}
	@Override
	public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
		setBinaryStream(nameToIndex(parameterName), x, length);
	}
	@Override
	public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException {
		setBinaryStream(nameToIndex(parameterName), x, length);
	}
	@Override
	public void setBlob(String parameterName, Blob x) throws SQLException {
		setBlob(nameToIndex(parameterName), x);
	}
	@Override
	public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
		setBlob(nameToIndex(parameterName), inputStream);
	}
	@Override
	public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
		setBlob(nameToIndex(parameterName), inputStream, length);
	}
	@Override
	public void setBoolean(String parameterName, boolean x) throws SQLException {
		setBoolean(nameToIndex(parameterName), x);
	}
	@Override
	public void setByte(String parameterName, byte x) throws SQLException {
		setByte(nameToIndex(parameterName), x);
	}
	@Override
	public void setBytes(String parameterName, byte[] x) throws SQLException {
		setBytes(nameToIndex(parameterName), x);
	}
	@Override
	public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
		setCharacterStream(nameToIndex(parameterName), reader);
	}
	@Override
	public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
		setCharacterStream(nameToIndex(parameterName), reader, length);
	}
	@Override
	public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException {
		setCharacterStream(nameToIndex(parameterName), reader, length);
	}
	@Override
	public void setClob(String parameterName, Clob x) throws SQLException {
		setClob(nameToIndex(parameterName), x);
	}
	@Override
	public void setClob(String parameterName, Reader reader) throws SQLException {
		setClob(nameToIndex(parameterName), reader);
	}
	@Override
	public void setClob(String parameterName, Reader reader, long length) throws SQLException {
		setClob(nameToIndex(parameterName), reader, length);
	}
	@Override
	public void setDate(String parameterName, Date x) throws SQLException {
		setDate(nameToIndex(parameterName), x);
	}
	@Override
	public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
		setDate(nameToIndex(parameterName), x, cal);
	}
	@Override
	public void setDouble(String parameterName, double x) throws SQLException {
		setDouble(nameToIndex(parameterName), x);
	}
	@Override
	public void setFloat(String parameterName, float x) throws SQLException {
		setFloat(nameToIndex(parameterName), x);
	}
	@Override
	public void setInt(String parameterName, int x) throws SQLException {
		setInt(nameToIndex(parameterName), x);
	}
	@Override
	public void setLong(String parameterName, long x) throws SQLException {
		setLong(nameToIndex(parameterName), x);
	}
	@Override
	public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
		setNCharacterStream(nameToIndex(parameterName), value);
	}
	@Override
	public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
		setNCharacterStream(nameToIndex(parameterName), value, length);
	}
	@Override
	public void setNClob(String parameterName, NClob value) throws SQLException {
		setNClob(nameToIndex(parameterName), value);
	}
	@Override
	public void setNClob(String parameterName, Reader reader) throws SQLException {
		setNClob(nameToIndex(parameterName), reader);
	}
	@Override
	public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
		setNClob(nameToIndex(parameterName), reader, length);
	}
	@Override
	public void setNString(String parameterName, String value) throws SQLException {
		setNString(nameToIndex(parameterName), value);
	}
	@Override
	public void setNull(String parameterName, int sqlType) throws SQLException {
		setNull(nameToIndex(parameterName), sqlType);
	}
	@Override
	public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
		setNull(nameToIndex(parameterName), sqlType, typeName);
	}
	@Override
	public void setObject(String parameterName, Object x) throws SQLException {
		setObject(nameToIndex(parameterName), x);
	}
	@Override
	public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
		setObject(nameToIndex(parameterName), x, targetSqlType);
	}
	@Override
	public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
		setObject(nameToIndex(parameterName), x, targetSqlType, scale);
	}
	@Override
	public void setRowId(String parameterName, RowId x) throws SQLException {
		setRowId(nameToIndex(parameterName), x);
	}
	@Override
	public void setShort(String parameterName, short x) throws SQLException {
		setShort(nameToIndex(parameterName), x);
	}
	@Override
	public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
		setSQLXML(nameToIndex(parameterName), xmlObject);
	}
	@Override
	public void setString(String parameterName, String x) throws SQLException {
		setString(nameToIndex(parameterName), x);
	}
	@Override
	public void setTime(String parameterName, Time x) throws SQLException {
		setTime(nameToIndex(parameterName), x);
	}
	@Override
	public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
		setTime(nameToIndex(parameterName), x, cal);
	}
	@Override
	public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
		setTimestamp(nameToIndex(parameterName), x);
	}
	@Override
	public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
		setTimestamp(nameToIndex(parameterName), x, cal);
	}
	@Override
	public void setURL(String parameterName, URL val) throws SQLException {
		setURL(nameToIndex(parameterName), val);
	}

	/* Retrieves whether the last OUT parameter read had the value of SQL NULL. */
	@Override
	public boolean wasNull() throws SQLException {
		// wasNull() method is NOT supported
		// because output parameters in stored procedures are not supported by MonetDB
		throw newSQLFeatureNotSupportedException("wasNull");
	}

	//== Java 1.8 methods (JDBC 4.2)

	@Override
	public void setObject(String parameterName, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException {
		// setObject(nameToIndex(parameterName), x, convertSQLType(targetSqlType), scaleOrLength);	// TODO implement convertSQLType(targetSqlType)
		throw newSQLFeatureNotSupportedException("setObject");
	}

	@Override
	public void setObject(String parameterName, Object x, SQLType targetSqlType) throws SQLException {
		// setObject(nameToIndex(parameterName), x, convertSQLType(targetSqlType));	// TODO implement convertSQLType(targetSqlType)
		throw newSQLFeatureNotSupportedException("setObject");
	}

	@Override
	public void registerOutParameter(int parameterIndex, SQLType sqlType) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(int parameterIndex, SQLType sqlType, int scale) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(int parameterIndex, SQLType sqlType, String typeName) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(String parameterName, SQLType sqlType) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(String parameterName, SQLType sqlType, int scale) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}
	@Override
	public void registerOutParameter(String parameterName, SQLType sqlType, String typeName) throws SQLException {
		throw newSQLFeatureNotSupportedException("registerOutParameter");
	}

	// end methods interface CallableStatement
}