callablestatement.java

derby database source code.good for you.

        }
    }

    public String getString(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getString", parameterIndex);
            }
            String result = getStringX(parameterIndex);
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getString", result);
            }
            return result;
        }
    }

    // also used by SQLCA
    String getStringX(int parameterIndex) throws SqlException {
        super.checkForClosedStatement();
        parameterIndex = checkForEscapedCallWithResult(parameterIndex);
        if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
            this.wasNull_ = this.WAS_NOT_NULL;
            return Integer.toString(returnValueFromProcedure_);
        }
        checkGetterPreconditions(parameterIndex);
        setWasNull(parameterIndex);
        return wasNullX() ? null : singletonRowData_.getString(parameterIndex);
    }

    public byte[] getBytes(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getBytes", parameterIndex);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
                throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call.");
            }
            checkGetterPreconditions(parameterIndex);
            setWasNull(parameterIndex);
            byte[] result = wasNullX() ? null : singletonRowData_.getBytes(parameterIndex);
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getBytes", result);
            }
            return result;
        }
    }

    public java.sql.Blob getBlob(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getBlob", parameterIndex);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
                throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call.");
            }
            checkGetterPreconditions(parameterIndex);
            setWasNull(parameterIndex);
            java.sql.Blob result = wasNullX() ? null : singletonRowData_.getBlob(parameterIndex);
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getBlob", result);
            }
            return result;
        }
    }

    public java.sql.Clob getClob(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getClob", parameterIndex);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
                throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call.");
            }
            checkGetterPreconditions(parameterIndex);
            setWasNull(parameterIndex);
            java.sql.Clob result = wasNullX() ? null : singletonRowData_.getClob(parameterIndex);
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getClob", result);
            }
            return result;
        }
    }

    public java.sql.Array getArray(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getArray", parameterIndex);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
                throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call.");
            }
            checkGetterPreconditions(parameterIndex);
            setWasNull(parameterIndex);
            java.sql.Array result = wasNullX() ? null : singletonRowData_.getArray(parameterIndex);
            if (true) {
                throw new SqlException(agent_.logWriter_, "jdbc 2 method is not yet implemented");
            }
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getArray", result);
            }
            return result;
        }
    }

    public java.sql.Ref getRef(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getRef", parameterIndex);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
                throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call.");
            }
            checkGetterPreconditions(parameterIndex);
            setWasNull(parameterIndex);
            java.sql.Ref result = wasNullX() ? null : singletonRowData_.getRef(parameterIndex);
            if (true) {
                throw new SqlException(agent_.logWriter_, "jdbc 2 method is not yet implemented");
            }
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getRef", result);
            }
            return result;
        }
    }

    public Object getObject(int parameterIndex) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getObject", parameterIndex);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            Object result;
            if (parameterIndex == 0 && escapedProcedureCallWithResult_) {
                result = new Integer(returnValueFromProcedure_);
                this.wasNull_ = this.WAS_NOT_NULL;
                if (agent_.loggingEnabled()) {
                    agent_.logWriter_.traceExit(this, "getObject", result);
                }
                return result;
            }
            checkGetterPreconditions(parameterIndex);
            setWasNull(parameterIndex);
            result = wasNullX() ? null : singletonRowData_.getObject(parameterIndex);
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getObject", result);
            }
            return result;
        }
    }

    public Object getObject(int parameterIndex, java.util.Map map) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "getObject", parameterIndex, map);
            }
            super.checkForClosedStatement();
            parameterIndex = checkForEscapedCallWithResult(parameterIndex);
            Object result;
            checkGetterPreconditions(parameterIndex);
            if (true) {
                throw new SqlException(agent_.logWriter_, "jdbc 2 method is not yet implemented.");
            }
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceExit(this, "getObject", result);
            }
            return result;
        }
    }

    //--------------------------JDBC 3.0------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    public void setTime(String parameterName, java.sql.Time x) throws SqlException {
        if (agent_.loggingEnabled()) {