callablestatement.java

derby database source code.good for you.

            agent_.logWriter_.traceEntry(this, "setTime", parameterName, x);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setTimestamp(String parameterName, java.sql.Timestamp x) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setTimestamp", parameterName, x);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setAsciiStream(String parameterName, java.io.InputStream x, int length) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setAsciiStream", parameterName, x, length);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setBinaryStream(String parameterName, java.io.InputStream x, int length) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setBinaryStream", parameterName, x, length);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setObject", parameterName, x, targetSqlType, scale);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setObject(String parameterName, Object x, int targetSqlType) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setObject", parameterName, x, targetSqlType);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setObject(String parameterName, Object x) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setObject", parameterName, x);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setCharacterStream(String parameterName, java.io.Reader reader, int length) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setCharacterStream", parameterName, reader, length);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setDate(String parameterName, java.sql.Date x, java.util.Calendar calendar) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setDate", parameterName, x, calendar);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setTime(String parameterName, java.sql.Time x, java.util.Calendar calendar) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setTime", parameterName, x, calendar);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setTimestamp(String parameterName, java.sql.Timestamp x, java.util.Calendar calendar) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setTimestamp", parameterName, x, calendar);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public void setNull(String parameterName, int sqlType, String typeName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "setNull", parameterName, sqlType, typeName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public String getString(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getString", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public boolean getBoolean(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getBoolean", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public byte getByte(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getByte", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public short getShort(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getShort", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public int getInt(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getInt", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public long getLong(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getLong", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public float getFloat(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getFloat", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public double getDouble(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getDouble", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public byte[] getBytes(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getBytes", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Date getDate(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getDate", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Time getTime(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getTime", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Timestamp getTimestamp(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getTimestamp", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public Object getObject(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getObject", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.math.BigDecimal getBigDecimal(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getBigDecimal", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public Object getObject(String parameterName, java.util.Map map) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getObject", parameterName, map);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Ref getRef(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getRef", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Blob getBlob(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getBlob", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Clob getClob(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getClob", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Array getArray(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getArray", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Date getDate(String parameterName, java.util.Calendar calendar) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getDate", parameterName, calendar);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Time getTime(String parameterName, java.util.Calendar calendar) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getTime", parameterName, calendar);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.sql.Timestamp getTimestamp(String parameterName, java.util.Calendar calendar) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getTimestamp", parameterName, calendar);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    public java.net.URL getURL(String parameterName) throws SqlException {
        if (agent_.loggingEnabled()) {
            agent_.logWriter_.traceEntry(this, "getURL", parameterName);
        }
        super.checkForClosedStatement();
        throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported");
    }

    //----------------------------helper methods----------------------------------

    private int checkForEscapedCallWithResult(int parameterIndex) throws SqlException {
        if (escapedProcedureCallWithResult_) {
            parameterIndex--;
        }
        return parameterIndex;
    }

    private int checkForEscapedCallWithResult(int parameterIndex, int jdbcType) throws SqlException {
        if (escapedProcedureCallWithResult_) {
            if (parameterIndex == 1 && jdbcType != java.sql.Types.INTEGER) {
                throw new SqlException(agent_.logWriter_, "Parameter 1 is the return caluse of the stored procedure call, it can only be registered as an integer type");
            } else {
                parameterIndex--;
            }
        }
        return parameterIndex;
    }

    private void checkGetterPreconditions(int parameterIndex) throws SqlException {
        super.checkForValidParameterIndex(parameterIndex);
        checkForValidOutParameter(parameterIndex);
    }

    private void checkForValidOutParameter(int parameterIndex) throws SqlException {
        if (parameterMetaData_ == null || parameterMetaData_.sqlxParmmode_[parameterIndex - 1] < java.sql.ParameterMetaData.parameterModeInOut) {
            throw new SqlException(agent_.logWriter_, "Invalid argument: parameter index " + parameterIndex +
                    " is not an OUT or INOUT parameter.");
        }
    }

    private void setWasNull(int parameterIndex) {
        if (singletonRowData_ == null) {
            wasNull_ = WAS_NULL_UNSET;
        } else {
            wasNull_ = singletonRowData_.isNull_[parameterIndex - 1] ? WAS_NULL : WAS_NOT_NULL;
        }
    }
}