| /* |
| |
| Derby - Class org.apache.derby.impl.jdbc.EmbedCallableStatement |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to you under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| package org.apache.derby.impl.jdbc; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.io.UnsupportedEncodingException; |
| import org.apache.derby.iapi.sql.ParameterValueSet; |
| import org.apache.derby.iapi.sql.Activation; |
| import org.apache.derby.iapi.error.StandardException; |
| import org.apache.derby.iapi.types.DataValueDescriptor; |
| |
| import org.apache.derby.shared.common.sanity.SanityManager; |
| |
| import org.apache.derby.iapi.reference.SQLState; |
| |
| 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.SQLException; |
| import java.sql.Date; |
| import java.sql.NClob; |
| import java.sql.ParameterMetaData; |
| import java.sql.Ref; |
| import java.sql.RowId; |
| import java.sql.SQLXML; |
| import java.sql.Statement; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.sql.Types; |
| import java.util.Calendar; |
| import java.util.Map; |
| import org.apache.derby.iapi.jdbc.CharacterStreamDescriptor; |
| import org.apache.derby.iapi.jdbc.EngineCallableStatement; |
| import org.apache.derby.iapi.types.StringDataValue; |
| |
| /** |
| * Local implementation. |
| * |
| */ |
| public class EmbedCallableStatement extends EmbedPreparedStatement |
| implements EngineCallableStatement |
| { |
| /* |
| ** True if we are of the form ? = CALL() -- i.e. true |
| ** if we have a return output parameter. |
| */ |
| private boolean hasReturnOutputParameter; |
| |
| protected boolean wasNull; |
| |
| /** |
| * @exception SQLException thrown on failure |
| */ |
| public EmbedCallableStatement (EmbedConnection conn, String sql, |
| int resultSetType, |
| int resultSetConcurrency, |
| int resultSetHoldability) |
| throws SQLException |
| { |
| super(conn, sql, false, |
| resultSetType, |
| resultSetConcurrency, |
| resultSetHoldability, |
| Statement.NO_GENERATED_KEYS, |
| null, |
| null); |
| |
| // mark our parameters as for a callable statement |
| ParameterValueSet pvs = getParms(); |
| |
| // do we have a return parameter? |
| hasReturnOutputParameter = pvs.hasReturnOutputParameter(); |
| } |
| |
| protected void checkRequiresCallableStatement(Activation activation) { |
| } |
| |
| protected final boolean executeStatement(Activation a, |
| boolean executeQuery, boolean executeUpdate) |
| throws SQLException |
| { |
| // need this additional check (it's also in the super.executeStatement |
| // to ensure we have an activation for the getParams |
| checkExecStatus(); |
| synchronized (getConnectionSynchronization()) |
| { |
| wasNull = false; |
| //Don't fetch the getParms into a local varibale |
| //at this point because it is possible that the activation |
| //associated with this callable statement may have become |
| //stale. If the current activation is invalid, a new activation |
| //will be created for it in executeStatement call below. |
| //We should be using the ParameterValueSet associated with |
| //the activation associated to the CallableStatement after |
| //the executeStatement below. That ParameterValueSet is the |
| //right object to hold the return value from the CallableStatement. |
| try |
| { |
| getParms().validate(); |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| /* KLUDGE - ? = CALL ... returns a ResultSet(). We |
| * need executeUpdate to be false in that case. |
| */ |
| boolean execResult = super.executeStatement(a, executeQuery, |
| (executeUpdate && (! hasReturnOutputParameter))); |
| |
| //Fetch the getParms into a local variable now because the |
| //activation associated with a CallableStatement at this |
| //point(after the executStatement) is the current activation. |
| //We can now safely stuff the return value of the |
| //CallableStatement into the following ParameterValueSet object. |
| ParameterValueSet pvs = getParms(); |
| |
| /* |
| ** If we have a return parameter, then we |
| ** consume it from the returned ResultSet |
| ** reset the ResultSet set to null. |
| */ |
| if (hasReturnOutputParameter) |
| { |
| if (SanityManager.DEBUG) |
| { |
| SanityManager.ASSERT(results!=null, "null results even though we are supposed to have a return parameter"); |
| } |
| boolean gotRow = results.next(); |
| if (SanityManager.DEBUG) |
| { |
| SanityManager.ASSERT(gotRow, "the return resultSet didn't have any rows"); |
| } |
| |
| try |
| { |
| DataValueDescriptor returnValue = pvs.getReturnValueForSet(); |
| returnValue.setValueFromResultSet(results, 1, true); |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| finally { |
| results.close(); |
| results = null; |
| } |
| |
| // This is a form of ? = CALL which current is not a procedure call. |
| // Thus there cannot be any user result sets, so return false. execResult |
| // is set to true since a result set was returned, for the return parameter. |
| execResult = false; |
| } |
| return execResult; |
| } |
| } |
| |
| /* |
| * CallableStatement interface |
| * (the PreparedStatement part implemented by EmbedPreparedStatement) |
| */ |
| |
| /** |
| * @see CallableStatement#registerOutParameter |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public final void registerOutParameter(int parameterIndex, int sqlType) |
| throws SQLException |
| { |
| checkStatus(); |
| |
| try { |
| getParms().registerOutParameter(parameterIndex-1, sqlType, -1); |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| |
| /** |
| * @see CallableStatement#registerOutParameter |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public final void registerOutParameter(int parameterIndex, int sqlType, int scale) |
| throws SQLException |
| { |
| checkStatus(); |
| |
| if (scale < 0) |
| throw newSQLException(SQLState.BAD_SCALE_VALUE, scale); |
| try { |
| getParms().registerOutParameter(parameterIndex-1, sqlType, scale); |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Derby ignores the typeName argument because UDTs don't need it. |
| * |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public void registerOutParameter(int parameterIndex, int sqlType, |
| String typeName) |
| throws SQLException |
| { |
| registerOutParameter( parameterIndex, sqlType ); |
| } |
| |
| |
| |
| /** |
| * @see CallableStatement#wasNull |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public boolean wasNull() throws SQLException |
| { |
| checkStatus(); |
| return wasNull; |
| } |
| |
| /** |
| * @see CallableStatement#getString |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public String getString(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| String v = getParms().getParameterForGet(parameterIndex-1).getString(); |
| wasNull = (v == null); |
| return v; |
| |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| |
| /** |
| * @see CallableStatement#getBoolean |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public boolean getBoolean(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| boolean v = param.getBoolean(); |
| wasNull = (!v) && param.isNull(); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getByte |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public byte getByte(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| byte b = param.getByte(); |
| wasNull = (b == 0) && param.isNull(); |
| return b; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getShort |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public short getShort(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| short s = param.getShort(); |
| wasNull = (s == 0) && param.isNull(); |
| return s; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getInt |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public int getInt(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| int v = param.getInt(); |
| wasNull = (v == 0) && param.isNull(); |
| return v; |
| |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| |
| /** |
| * @see CallableStatement#getLong |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public long getLong(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| long v = param.getLong(); |
| wasNull = (v == 0L) && param.isNull(); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Get the value of a NUMERIC parameter as a java.math.BigDecimal object. |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return the parameter value (full precision); if the value is SQL NULL, |
| * the result is null |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public final BigDecimal getBigDecimal(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor dvd = getParms().getParameterForGet(parameterIndex-1); |
| if (wasNull = dvd.isNull()) |
| return null; |
| |
| return org.apache.derby.iapi.types.SQLDecimal.getBigDecimal(dvd); |
| |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| |
| /** |
| * @see CallableStatement#getBigDecimal |
| * @exception SQLException NoOutputParameters thrown. |
| * @deprecated |
| */ |
| public final BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException |
| { |
| BigDecimal v = getBigDecimal(parameterIndex); |
| if (v != null) |
| v = v.setScale(scale, BigDecimal.ROUND_HALF_DOWN); |
| return v; |
| } |
| |
| /** |
| * @see CallableStatement#getFloat |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public float getFloat(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| float v = param.getFloat(); |
| wasNull = (v == 0.0) && param.isNull(); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| |
| /** |
| * @see CallableStatement#getDouble |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public double getDouble(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| DataValueDescriptor param = getParms().getParameterForGet(parameterIndex-1); |
| double v = param.getDouble(); |
| wasNull = (v == 0.0) && param.isNull(); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getBytes |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public byte[] getBytes(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| byte[] v = getParms().getParameterForGet(parameterIndex-1).getBytes(); |
| wasNull = (v == null); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getDate |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public Date getDate(int parameterIndex, Calendar cal) throws SQLException |
| { |
| checkStatus(); |
| try { |
| Date v = getParms(). |
| getParameterForGet(parameterIndex-1).getDate(cal); |
| wasNull = (v == null); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getTime |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public Time getTime(int parameterIndex, Calendar cal) throws SQLException |
| { |
| checkStatus(); |
| try { |
| Time v = getParms(). |
| getParameterForGet(parameterIndex-1).getTime(cal); |
| wasNull = (v == null); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| |
| } |
| |
| /** |
| * @see CallableStatement#getTimestamp |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public Timestamp getTimestamp(int parameterIndex, Calendar cal) |
| throws SQLException |
| { |
| checkStatus(); |
| try { |
| Timestamp v = getParms(). |
| getParameterForGet(parameterIndex-1).getTimestamp(cal); |
| wasNull = (v == null); |
| return v; |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| /** |
| * Get the value of a SQL DATE parameter as a java.sql.Date object |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return the parameter value; if the value is SQL NULL, the result is |
| * null |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public java.sql.Date getDate(int parameterIndex) |
| throws SQLException |
| { |
| return getDate(parameterIndex, getCal()); |
| } |
| |
| /** |
| * Get the value of a SQL TIME parameter as a java.sql.Time object. |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return the parameter value; if the value is SQL NULL, the result is |
| * null |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public java.sql.Time getTime(int parameterIndex) |
| throws SQLException |
| { |
| return getTime(parameterIndex, getCal()); |
| } |
| |
| /** |
| * Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp |
| * object. |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return the parameter value; if the value is SQL NULL, the result is |
| * null |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public java.sql.Timestamp getTimestamp(int parameterIndex) |
| throws SQLException |
| { |
| return getTimestamp(parameterIndex, getCal()); |
| } |
| |
| /** |
| * @see CallableStatement#getObject |
| * @exception SQLException NoOutputParameters thrown. |
| */ |
| public final Object getObject(int parameterIndex) throws SQLException |
| { |
| checkStatus(); |
| try { |
| Object v = getParms().getParameterForGet(parameterIndex-1).getObject(); |
| wasNull = (v == null); |
| return v; |
| |
| } catch (StandardException e) |
| { |
| throw EmbedResultSet.noStateChangeException(e); |
| } |
| } |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieve the value of the designated JDBC DATALINK parameter as a java.net.URL object |
| * |
| * @param parameterIndex - the first parameter is 1, the second is 2 |
| * @return a java.net.URL object that represents the JDBC DATALINK value used as |
| * the designated parameter |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public URL getURL(int parameterIndex) |
| throws SQLException |
| { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.net.URL object. The driver |
| * converts this to an SQL DATALINK value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param val - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public void setURL(String parameterName, URL val) |
| throws SQLException |
| { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC DATALINK parameter as a java.net.URL object |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public URL getURL(String parameterName) |
| throws SQLException |
| { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Get a BLOB OUT parameter. |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return an object representing a BLOB |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public Blob getBlob (int parameterIndex) throws SQLException { |
| Object o = getObject(parameterIndex); |
| if (o == null || o instanceof Blob) { |
| return (Blob) o; |
| } |
| throw newSQLException(SQLState.LANG_DATA_TYPE_GET_MISMATCH, |
| Blob.class.getName(), |
| Util.typeName(getParameterJDBCType(parameterIndex))); |
| } |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Get a CLOB OUT parameter. |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return an object representing a CLOB |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public Clob getClob (int parameterIndex) throws SQLException { |
| Object o = getObject(parameterIndex); |
| if (o == null || o instanceof Clob) { |
| return (Clob) o; |
| } |
| throw newSQLException(SQLState.LANG_DATA_TYPE_GET_MISMATCH, |
| Clob.class.getName(), |
| Util.typeName(getParameterJDBCType(parameterIndex))); |
| } |
| |
| public void addBatch() throws SQLException { |
| |
| checkStatus(); |
| ParameterValueSet pvs = getParms(); |
| |
| int numberOfParameters = pvs.getParameterCount(); |
| |
| for (int j=1; j<=numberOfParameters; j++) { |
| |
| switch (pvs.getParameterMode(j)) { |
| case (ParameterMetaData.parameterModeIn): |
| case (ParameterMetaData.parameterModeUnknown): |
| break; |
| case (ParameterMetaData.parameterModeOut): |
| case (ParameterMetaData.parameterModeInOut): |
| throw newSQLException(SQLState.OUTPUT_PARAMS_NOT_ALLOWED); |
| } |
| } |
| |
| super.addBatch(); |
| } |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Returns an object representing the value of OUT parameter {@code i}. |
| * Use the map to determine the class from which to construct data of SQL |
| * structured and distinct types. |
| * |
| * @param i the first parameter is 1, the second is 2, ... |
| * @param map the mapping from SQL type names to Java classes |
| * @return a java.lang.Object holding the OUT parameter value. |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public final Object getObject(int i, Map<String, Class<?>> map) throws SQLException { |
| checkStatus(); |
| if (map == null) { |
| throw Util.generateCsSQLException(SQLState.INVALID_API_PARAMETER, map, "map", |
| "java.sql.CallableStatement.getObject"); |
| } |
| if (!map.isEmpty()) { |
| throw Util.notImplemented(); |
| } |
| // Map is empty call the normal getObject method. |
| return getObject(i); |
| } |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Get a REF(<structured-type>) OUT parameter. |
| * |
| * @param i the first parameter is 1, the second is 2, ... |
| * @return an object representing data of an SQL REF Type |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public final Ref getRef(int i) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 2.0 |
| * |
| * Get an Array OUT parameter. |
| * |
| * @param i the first parameter is 1, the second is 2, ... |
| * @return an object representing an SQL array |
| * @exception SQLException if a database-access error occurs. |
| */ |
| public final Array getArray(int i) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| // JDBC 3.0 methods |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Registers the OUT parameter named parameterName to the JDBC type sqlType. |
| * All OUT parameters must be registered before a stored procedure is |
| * executed. |
| * |
| * @param parameterName - the name of the parameter |
| * @param sqlType - the JDBC type code defined by java.sql.Types. If the |
| * parameter is of JDBC type NUMERIC or DECIMAL, the version of |
| * registerOutParameter that accepts a scale value should be used. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void registerOutParameter(String parameterName, int sqlType) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Registers the designated output parameter. This version of the method |
| * registerOutParameter should be used for a user-named or REF output |
| * parameter. |
| * |
| * @param parameterName - the name of the parameter |
| * @param sqlType - the SQL type code defined by java.sql.Types. |
| * @param typeName - the fully-qualified name of an SQL structure type |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void registerOutParameter(String parameterName, |
| int sqlType, String typeName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Registers the parameter named parameterName to the JDBC type sqlType. |
| * This method must be called before a stored procedure is executed. |
| * |
| * @param parameterName - the name of the parameter |
| * @param sqlType - the SQL type code defined by java.sql.Types. |
| * @param scale - the desired number of digits to the right of the decimal |
| * point. It must be greater than or equal to zero. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void registerOutParameter(String parameterName, |
| int sqlType, int scale) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC REF (structured-type) parameter as a Ref |
| * object in the Java programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value as a Ref object in the Java Programming |
| * language. If the value is SQL NULL, the result is null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Ref getRef(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC BLOB parameter as a Blob object in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value as a Blob object in the Java Programming |
| * language. If the value is SQL NULL, the result is null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Blob getBlob(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC CLOB parameter as a Clob object in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value as a Clob object in the Java Programming |
| * language. If the value is SQL NULL, the result is null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Clob getClob(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC ARRAY parameter as an Array object in the |
| * Java programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value as a Array object in the Java Programming |
| * language. If the value is SQL NULL, the result is null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Array getArray(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to SQL NULL. |
| * |
| * @param parameterName - the name of the parameter |
| * @param sqlType - the SQL type code defined in java.sql.Types |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setNull(String parameterName, int sqlType) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to SQL NULL. |
| * |
| * @param parameterName - the name of the parameter |
| * @param sqlType - the SQL type code defined in java.sql.Types |
| * @param typeName - the fully-qualified name of an SQL user-defined type |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setNull(String parameterName, int sqlType, String typeName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java boolean value. The driver |
| * converts this to an SQL BIT value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setBoolean(String parameterName, boolean x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC BIT parameter as a boolean in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * false. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final boolean getBoolean(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java byte value. The driver |
| * converts this to an SQL TINYINT value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setByte(String parameterName, byte x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC TINYINT parameter as a byte in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final byte getByte(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java short value. The driver |
| * converts this to an SQL SMALLINT value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setShort(String parameterName, short x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC SMALLINT parameter as a short in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final short getShort(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java int value. The driver |
| * converts this to an SQL INTEGER value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setInt(String parameterName, int x) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC INTEGER parameter as a int in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final int getInt(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java long value. The driver |
| * converts this to an SQL BIGINT value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setLong(String parameterName, long x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC BIGINT parameter as a long in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final long getLong(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java float value. The driver |
| * converts this to an SQL FLOAT value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setFloat(String parameterName, float x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC FLOAT parameter as a float in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final float getFloat(String parameterName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java double value. The driver |
| * converts this to an SQL DOUBLE value when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setDouble(String parameterName, double x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC DOUBLE parameter as a double in the Java |
| * programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final double getDouble(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.math.BigDecimal value. |
| * The driver converts this to an SQL NUMERIC value when it sends it to the |
| * database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setBigDecimal(String parameterName, BigDecimal x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC NUMERIC parameter as a java.math.BigDecimal |
| * object with as many digits to the right of the decimal point as the value |
| * contains |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is 0. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final BigDecimal getBigDecimal(String parameterName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java String value. The driver |
| * converts this to an SQL VARCHAR OR LONGVARCHAR value (depending on the |
| * argument's size relative the driver's limits on VARCHAR values) when it |
| * sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setString(String parameterName, String x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC CHAR, VARCHAR, or LONGVARCHAR parameter as |
| * a String in the Java programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final String getString(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Java array of bytes. The |
| * driver converts this to an SQL VARBINARY OR LONGVARBINARY (depending on |
| * the argument's size relative to the driver's limits on VARBINARY |
| * values)when it sends it to the database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setBytes(String parameterName, byte[] x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC BINARY or VARBINARY parameter as an array |
| * of byte values in the Java programming language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final byte[] getBytes(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.sql.Date value. The |
| * driver converts this to an SQL DATE value when it sends it to the |
| * database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setDate(String parameterName, Date x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.sql.Date value, using the |
| * given Calendar object. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @param cal - the Calendar object the driver will use to construct the |
| * date |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setDate(String parameterName, Date x, Calendar cal) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC DATE parameter as a java.sql.Date object |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Date getDate(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC DATE parameter as a java.sql.Date object, |
| * using the given Calendar object to construct the date object. |
| * |
| * @param parameterName - the name of the parameter |
| * @param cal - the Calendar object the driver will use to construct the |
| * date |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Date getDate(String parameterName, Calendar cal) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.sql.Time value. The |
| * driver converts this to an SQL TIME value when it sends it to the |
| * database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setTime(String parameterName, Time x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC TIME parameter as ajava.sql.Time object |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Time getTime(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC TIME parameter as a java.sql.Time object, |
| * using the given Calendar object to construct the time object. |
| * |
| * @param parameterName - the name of the parameter |
| * @param cal - the Calendar object the driver will use to construct the |
| * time |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Time getTime(String parameterName, Calendar cal) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.sql.Time value using the |
| * Calendar object |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @param cal - the Calendar object the driver will use to construct the |
| * time |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setTime(String parameterName, Time x, Calendar cal) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.sql.Timestamp value. The |
| * driver converts this to an SQL TIMESTAMP value when it sends it to the |
| * database. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setTimestamp(String parameterName, Timestamp x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given java.sql.Timestamp value, |
| * using the given Calendar object |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the parameter value |
| * @param cal - the Calendar object the driver will use to construct the |
| * timestamp. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setTimestamp(String parameterName, Timestamp x, Calendar cal) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC TIMESTAMP parameter as a java.sql.Timestamp |
| * object |
| * |
| * @param parameterName - the name of the parameter |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Timestamp getTimestamp(String parameterName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a JDBC TIMESTAMP parameter as a java.sql.Timestamp |
| * object, using the given Calendar object to construct the Timestamp |
| * object. |
| * |
| * @param parameterName - the name of the parameter |
| * @param cal - the Calendar object the driver will use to construct the |
| * Timestamp |
| * @return the parameter value. If the value is SQL NULL, the result is |
| * null. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Timestamp getTimestamp(String parameterName, Calendar cal) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given input stream, which will have |
| * the specified number of bytes. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the Java input stream that contains the ASCII parameter value |
| * @param length - the number of bytes in the stream |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setAsciiStream(String parameterName, InputStream x, int length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given input stream, which will have |
| * the specified number of bytes. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the Java input stream that contains the binary parameter value |
| * @param length - the number of bytes in the stream |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setBinaryStream(String parameterName, InputStream x, int length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the designated parameter to the given Reader object, which is the |
| * given number of characters long. |
| * |
| * @param parameterName - the name of the parameter |
| * @param reader - the java.io.Reader object that contains the UNICODE data |
| * @param length - the number of characters in the stream |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setCharacterStream(String parameterName, Reader reader, int length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the value of the designated parameter with the given object. The |
| * second argument must be an object type; for integral values, the |
| * java.lang equivalent objects should be used. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the object containing the input parameter value |
| * @param targetSqlType - the SQL type (as defined in java.sql.Types) to be |
| * sent to the database. The scale argument may further qualify this type. |
| * @param scale - for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC |
| * types, this is the number of digits after the decimal point. For all |
| * other types, this value will be ignored. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setObject(String parameterName, Object x, int targetSqlType, int scale) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Retrieves the value of a parameter as an Object in the java programming |
| * language. |
| * |
| * @param parameterName - the name of the parameter |
| * @return a java.lang.Object holding the OUT parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Object getObject(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Returns an object representing the value of OUT parameter i and uses map |
| * for the custom mapping of the parameter value. |
| * |
| * @param parameterName - the name of the parameter |
| * @param map - the mapping from SQL type names to Java classes |
| * @return a java.lang.Object holding the OUT parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final Object getObject(String parameterName, Map<String, Class<?>> map) |
| throws SQLException { |
| checkStatus(); |
| if (map == null) { |
| throw Util.generateCsSQLException(SQLState.INVALID_API_PARAMETER, map, "map", |
| "java.sql.CallableStatement.getObject"); |
| } |
| if (!(map.isEmpty())) { |
| throw Util.notImplemented(); |
| } |
| |
| // Map is empty so call the normal getObject method. |
| return getObject(parameterName); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the value of the designated parameter with the given object. This |
| * method is like the method setObject above, except that it assumes a scale |
| * of zero. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the object containing the input parameter value |
| * @param targetSqlType - the SQL type (as defined in java.sql.Types) to be |
| * sent to the database. |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setObject(String parameterName, Object x, int targetSqlType) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * JDBC 3.0 |
| * |
| * Sets the value of the designated parameter with the given object. The |
| * second parameter must be of type Object; therefore, the java.lang |
| * equivalent objects should be used for built-in types. |
| * |
| * @param parameterName - the name of the parameter |
| * @param x - the object containing the input parameter value |
| * @exception SQLException Feature not implemented for now. |
| */ |
| public final void setObject(String parameterName, Object x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| // JDBC 4.0 methods |
| |
| /** |
| * Retrieves the value of the designated parameter as a |
| * <code>java.io.Reader</code> object in the Java programming language. |
| * Introduced in JDBC 4.0. |
| * |
| * @param parameterIndex the first parameter is 1, the second is 2, ... |
| * @return a <code>java.io.Reader</code> object that contains the parameter |
| * value; if the value is SQL <code>NULL</code>, the value returned |
| * is <code>null</code> in the Java programming language. |
| * @throws SQLException if a database access error occurs or this method is |
| * called on a closed <code>CallableStatement</code> |
| */ |
| public final Reader getCharacterStream(int parameterIndex) |
| throws SQLException { |
| checkStatus(); |
| // Make sure the specified parameter has mode OUT or IN/OUT. |
| switch (getParms().getParameterMode(parameterIndex)) { |
| case (ParameterMetaData.parameterModeIn): |
| case (ParameterMetaData.parameterModeUnknown): |
| throw newSQLException(SQLState.LANG_NOT_OUTPUT_PARAMETER, |
| Integer.toString(parameterIndex)); |
| } |
| Reader reader = null; |
| int paramType = getParameterJDBCType(parameterIndex); |
| switch (paramType) { |
| // Handle character/string types. |
| case Types.CHAR: |
| case Types.VARCHAR: |
| case Types.LONGVARCHAR: |
| case Types.CLOB: |
| boolean pushStack = false; |
| Object syncObject = getConnectionSynchronization(); |
| synchronized (syncObject) { |
| try { |
| StringDataValue param = (StringDataValue) getParms().getParameterForGet(parameterIndex - 1); |
| if (param.isNull()) { |
| break; |
| } |
| pushStack = true; |
| setupContextStack(); |
| |
| if (param.hasStream()) { |
| CharacterStreamDescriptor csd = |
| param.getStreamWithDescriptor(); |
| reader = new UTF8Reader(csd, this, syncObject); |
| } else { |
| reader = new StringReader(param.getString()); |
| } |
| } catch (Throwable t) { |
| throw EmbedResultSet.noStateChangeException(t); |
| } finally { |
| if (pushStack) { |
| restoreContextStack(); |
| } |
| } |
| } // End synchronized block |
| break; |
| |
| // Handle binary types. |
| // JDBC says to support these, but no defintion exists for the output. |
| // Match JCC which treats the bytes as a UTF-16BE stream. |
| case Types.BINARY: |
| case Types.VARBINARY: |
| case Types.LONGVARBINARY: |
| case Types.BLOB: |
| try { |
| InputStream is = getBinaryStream(parameterIndex); |
| if (is != null) { |
| reader = new InputStreamReader(is, "UTF-16BE"); |
| } |
| break; |
| } catch (UnsupportedEncodingException uee) { |
| throw newSQLException(uee.getMessage()); |
| } |
| |
| default: |
| throw newSQLException(SQLState.LANG_DATA_TYPE_GET_MISMATCH, |
| "java.io.Reader", Util.typeName(paramType)); |
| } |
| // Update wasNull. |
| wasNull = (reader == null); |
| return reader; |
| } |
| |
| /** |
| * Get binary stream for a parameter. |
| * |
| * @param parameterIndex first parameter is 1, second is 2 etc. |
| * @return a stream for the binary parameter, or <code>null</code>. |
| * |
| * @throws SQLException if a database access error occurs. |
| */ |
| private InputStream getBinaryStream(int parameterIndex) |
| throws SQLException { |
| int paramType = getParameterJDBCType(parameterIndex); |
| switch (paramType) { |
| case Types.BINARY: |
| case Types.VARBINARY: |
| case Types.LONGVARBINARY: |
| case Types.BLOB: |
| break; |
| default: |
| throw newSQLException(SQLState.LANG_DATA_TYPE_GET_MISMATCH, |
| "java.io.InputStream", Util.typeName(paramType)); |
| } |
| |
| boolean pushStack = false; |
| synchronized (getConnectionSynchronization()) { |
| try { |
| DataValueDescriptor param = |
| getParms().getParameterForGet(parameterIndex - 1); |
| wasNull = param.isNull(); |
| if (wasNull) { |
| return null; |
| } |
| pushStack = true; |
| setupContextStack(); |
| |
| InputStream stream; // The stream we will return to the user |
| if (param.hasStream()) { |
| stream = new BinaryToRawStream(param.getStream(), param); |
| } else { |
| stream = new ByteArrayInputStream(param.getBytes()); |
| } |
| return stream; |
| } catch (Throwable t) { |
| throw EmbedResultSet.noStateChangeException(t); |
| } finally { |
| if (pushStack) { |
| restoreContextStack(); |
| } |
| } |
| } // End synchronized block |
| } |
| |
| public final Reader getCharacterStream(String parameterName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final Reader getNCharacterStream(int parameterIndex) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final Reader getNCharacterStream(String parameterName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final String getNString(int parameterIndex) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final String getNString(String parameterName) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setBlob(String parameterName, Blob x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setClob(String parameterName, Clob x) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final RowId getRowId(int parameterIndex) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final RowId getRowId(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setRowId(String parameterName, RowId x) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setNString(String parameterName, String value) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setNCharacterStream(String parameterName, Reader value, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setNClob(String parameterName, NClob value) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setClob(String parameterName, Reader reader, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| |
| } |
| |
| public final void setBlob(String parameterName, InputStream inputStream, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setNClob(String parameterName, Reader reader, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final NClob getNClob(int i) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final NClob getNClob(String parameterName) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException { |
| throw Util.notImplemented(); |
| |
| } |
| |
| public final SQLXML getSQLXML(int parameterIndex) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final SQLXML getSQLXML(String parametername) throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| public final void setAsciiStream(String parameterName, InputStream x) |
| throws SQLException { |
| throw Util.notImplemented("setAsciiStream(String,InputStream)"); |
| } |
| |
| public final void setBinaryStream(String parameterName, InputStream x) |
| throws SQLException { |
| throw Util.notImplemented("setBinaryStream(String,InputStream)"); |
| } |
| |
| public final void setBlob(String parameterName, InputStream inputStream) |
| throws SQLException { |
| throw Util.notImplemented("setBlob(String,InputStream)"); |
| } |
| |
| public final void setCharacterStream(String parameterName, Reader reader) |
| throws SQLException { |
| throw Util.notImplemented("setCharacterStream(String,Reader)"); |
| } |
| |
| public final void setClob(String parameterName, Reader reader) |
| throws SQLException { |
| throw Util.notImplemented("setClob(String,Reader)"); |
| } |
| |
| public final void setNCharacterStream(String parameterName, Reader value) |
| throws SQLException { |
| throw Util.notImplemented("setNCharacterStream(String,Reader)"); |
| } |
| |
| public final void setNClob(String parameterName, Reader reader) |
| throws SQLException { |
| throw Util.notImplemented("setNClob(String,Reader)"); |
| } |
| |
| /** |
| * Sets the designated parameter to the given input stream, which will have |
| * the specified number of bytes. |
| * |
| * @param parameterName the name of the first parameter |
| * @param x the java input stream which contains the ASCII parameter value |
| * @param length the number of bytes in the stream |
| * @exception SQLException thrown on failure. |
| * |
| */ |
| public final void setAsciiStream(String parameterName, InputStream x, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * Sets the designated parameter to the given input stream, which will have |
| * the specified number of bytes. |
| * |
| * @param parameterName the name of the first parameter |
| * @param x the java input stream which contains the binary parameter value |
| * @param length the number of bytes in the stream |
| * @exception SQLException thrown on failure. |
| * |
| */ |
| public final void setBinaryStream(String parameterName, InputStream x, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| /** |
| * Sets the designated parameter to the given Reader, which will have the |
| * specified number of bytes. |
| * |
| * @param parameterName the name of the first parameter |
| * @param x the java Reader which contains the UNICODE value |
| * @param length the number of bytes in the stream |
| * @exception SQLException thrown on failure. |
| * |
| */ |
| public final void setCharacterStream(String parameterName, Reader x, long length) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| //////////////////////////////////////////////////////////////////// |
| // |
| // INTRODUCED BY JDBC 4.1 IN JAVA 7 |
| // |
| //////////////////////////////////////////////////////////////////// |
| public final <T> T getObject(int parameterIndex, Class<T> type) |
| throws SQLException { |
| checkStatus(); |
| |
| if (type == null) { |
| throw mismatchException("NULL", parameterIndex); |
| } |
| |
| Object retval; |
| |
| if (String.class.equals(type)) { |
| retval = getString(parameterIndex); |
| } else if (BigDecimal.class.equals(type)) { |
| retval = getBigDecimal(parameterIndex); |
| } else if (Boolean.class.equals(type)) { |
| retval = getBoolean(parameterIndex); |
| } else if (Byte.class.equals(type)) { |
| retval = getByte(parameterIndex); |
| } else if (Short.class.equals(type)) { |
| retval = getShort(parameterIndex); |
| } else if (Integer.class.equals(type)) { |
| retval = getInt(parameterIndex); |
| } else if (Long.class.equals(type)) { |
| retval = getLong(parameterIndex); |
| } else if (Float.class.equals(type)) { |
| retval = getFloat(parameterIndex); |
| } else if (Double.class.equals(type)) { |
| retval = getDouble(parameterIndex); |
| } else if (Date.class.equals(type)) { |
| retval = getDate(parameterIndex); |
| } else if (Time.class.equals(type)) { |
| retval = getTime(parameterIndex); |
| } else if (Timestamp.class.equals(type)) { |
| retval = getTimestamp(parameterIndex); |
| } else if (Blob.class.equals(type)) { |
| retval = getBlob(parameterIndex); |
| } else if (Clob.class.equals(type)) { |
| retval = getClob(parameterIndex); |
| } else if (type.isArray() && type.getComponentType().equals(byte.class)) { |
| retval = getBytes(parameterIndex); |
| } else { |
| retval = getObject(parameterIndex); |
| } |
| |
| if (wasNull()) { |
| retval = null; |
| } |
| |
| if ((retval == null) || (type.isInstance(retval))) { |
| return type.cast(retval); |
| } |
| |
| throw mismatchException(type.getName(), parameterIndex); |
| } |
| |
| private SQLException mismatchException(String targetTypeName, int parameterIndex) |
| throws SQLException { |
| String sourceTypeName = getParameterMetaData().getParameterTypeName(parameterIndex); |
| return newSQLException(SQLState.LANG_DATA_TYPE_GET_MISMATCH, targetTypeName, sourceTypeName); |
| } |
| |
| public final <T> T getObject(String parameterName, Class<T> type) |
| throws SQLException { |
| throw Util.notImplemented(); |
| } |
| |
| } |
| |
