preparedstatement.java

来自「derby database source code.good for you.」· Java 代码 · 共 1,533 行 · 第 1/5 页

    int executeUpdateX() throws SqlException {
        flowExecute(executeUpdateMethod__);

        if (sqlMode_ == isUpdate__) {
            super.checkExecuteUpdatePostConditions("java.sql.PreparedStatement");
        }
        return updateCount_;
    }

    public void setNull(int parameterIndex, int jdbcType) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setNull", parameterIndex, jdbcType);
            }
            setNullX(parameterIndex, jdbcType);
        }
    }

    // also used by DBMD methods
    void setNullX(int parameterIndex, int jdbcType) throws SqlException {
        super.checkForClosedStatement();  // investigate what can be pushed up to setNull
        parameterIndex = checkSetterPreconditions(parameterIndex);
        parameterMetaData_.clientParamtertype_[parameterIndex - 1] = jdbcType;

        if (!parameterMetaData_.nullable_[parameterIndex - 1]) {
            throw new SqlException(agent_.logWriter_, "PreparedStatement: setNull method setting a non-nullable " +
                    "input parameter " + parameterIndex + " to null.");
        }
        setInput(parameterIndex, null);
    }

    public void setNull(int parameterIndex, int jdbcType, String typeName) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setNull", parameterIndex, jdbcType, typeName);
            }
            super.checkForClosedStatement();
            setNull(parameterIndex, jdbcType);
        }
    }

    public void setBoolean(int parameterIndex, boolean x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setBoolean", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.BIT;
            setInput(parameterIndex, new Short((short) (x ? 1 : 0)));
        }
    }

    public void setByte(int parameterIndex, byte x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setByte", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.TINYINT;
            setInput(parameterIndex, new Short(x));
        }
    }

    public void setShort(int parameterIndex, short x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setShort", parameterIndex, x);
            }
            setShortX(parameterIndex, x);
        }
    }

    // also used by DBMD methods
    void setShortX(int parameterIndex, short x) throws SqlException {
        parameterIndex = checkSetterPreconditions(parameterIndex);
        parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.SMALLINT;
        setInput(parameterIndex, new Short(x));

    }

    public void setInt(int parameterIndex, int x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setInt", parameterIndex, x);
            }
            setIntX(parameterIndex, x);
        }
    }

    // also used by DBMD methods
    void setIntX(int parameterIndex, int x) throws SqlException {
        parameterIndex = checkSetterPreconditions(parameterIndex);
        parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.INTEGER;
        setInput(parameterIndex, new Integer(x));
    }


    public void setLong(int parameterIndex, long x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setLong", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.BIGINT;
            setInput(parameterIndex, new Long(x));
        }
    }

    public void setFloat(int parameterIndex, float x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setFloat", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.REAL;
            setInput(parameterIndex, new Float(x));
        }
    }

    public void setDouble(int parameterIndex, double x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setDouble", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.DOUBLE;
            setInput(parameterIndex, new Double(x));
        }
    }

    public void setBigDecimal(int parameterIndex, java.math.BigDecimal x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setBigDecimal", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.DECIMAL;
            if (x == null) {
                setNull(parameterIndex, java.sql.Types.DECIMAL);
                return;
            }
            int registerOutScale = 0;
            setInput(parameterIndex, x);
        }
    }

    public void setDate(int parameterIndex, java.sql.Date x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setDate", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.DATE;
            if (x == null) {
                setNull(parameterIndex, java.sql.Types.DATE);
                return;
            }
            setInput(parameterIndex, x);
        }
    }

    public void setDate(int parameterIndex,
                        java.sql.Date x,
                        java.util.Calendar calendar) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setDate", parameterIndex, x, calendar);
            }
            if (calendar == null) {
                throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
            }
            java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
            targetCalendar.clear();
            targetCalendar.setTime(x);
            java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
            defaultCalendar.clear();
            defaultCalendar.setTime(x);
            long timeZoneOffset =
                    targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
                    targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
            java.sql.Date adjustedDate = ((timeZoneOffset == 0) || (x == null)) ? x : new java.sql.Date(x.getTime() + timeZoneOffset);
            setDate(parameterIndex, adjustedDate);
        }
    }

    public void setTime(int parameterIndex, java.sql.Time x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setTime", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.TIME;
            if (x == null) {
                setNull(parameterIndex, java.sql.Types.TIME);
                return;
            }
            setInput(parameterIndex, x);

        }
    }

    public void setTime(int parameterIndex,
                        java.sql.Time x,
                        java.util.Calendar calendar) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setTime", parameterIndex, x, calendar);
            }
            if (calendar == null) {
                throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
            }
            java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
            targetCalendar.clear();
            targetCalendar.setTime(x);
            java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
            defaultCalendar.clear();
            defaultCalendar.setTime(x);
            long timeZoneOffset =
                    targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
                    targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
            java.sql.Time adjustedTime = ((timeZoneOffset == 0) || (x == null)) ? x : new java.sql.Time(x.getTime() + timeZoneOffset);
            setTime(parameterIndex, adjustedTime);
        }
    }

    public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setTimestamp", parameterIndex, x);
            }
            parameterIndex = checkSetterPreconditions(parameterIndex);
            parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.TIMESTAMP;

            if (x == null) {
                setNull(parameterIndex, java.sql.Types.TIMESTAMP);
                return;
            }
            setInput(parameterIndex, x);
            // once the nanosecond field of timestamp is trim to microsecond for DERBY, should we throw a warning
            //if (getParameterType (parameterIndex) == java.sql.Types.TIMESTAMP && x.getNanos() % 1000 != 0)
            //  accumulateWarning (new SqlWarning (agent_.logWriter_, "DERBY timestamp can only store up to microsecond, conversion from nanosecond to microsecond causes rounding."));
        }
    }

    public void setTimestamp(int parameterIndex,
                             java.sql.Timestamp x,
                             java.util.Calendar calendar) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setTimestamp", parameterIndex, x, calendar);
            }
            if (calendar == null) {
                throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
            }
            java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
            targetCalendar.clear();
            targetCalendar.setTime(x);
            java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
            defaultCalendar.clear();
            defaultCalendar.setTime(x);
            long timeZoneOffset =
                    targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
                    targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
            java.sql.Timestamp adjustedTimestamp = ((timeZoneOffset == 0) || (x == null)) ? x : new java.sql.Timestamp(x.getTime() + timeZoneOffset);
            if (x != null) {
                adjustedTimestamp.setNanos(x.getNanos());
            }
            setTimestamp(parameterIndex, adjustedTimestamp);
        }
    }

    public void setString(int parameterIndex, String x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setString", parameterIndex, x);
            }
            setStringX(parameterIndex, x);
        }
    }

    // also used by DBMD methods
    void setStringX(int parameterIndex, String x) throws SqlException {
        parameterIndex = checkSetterPreconditions(parameterIndex);
        parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.LONGVARCHAR;
        if (x == null) {
            setNull(parameterIndex, java.sql.Types.LONGVARCHAR);
            return;
        }
        setInput(parameterIndex, x);
    }

    public void setBytes(int parameterIndex, byte[] x) throws SqlException {
        synchronized (connection_) {
            if (agent_.loggingEnabled()) {
                agent_.logWriter_.traceEntry(this, "setBytes", parameterIndex, x);
            }
            setBytesX(parameterIndex, x);
        }
    }

    // also used by BLOB
    public void setBytesX(int parameterIndex, byte[] x) throws SqlException {
        parameterIndex = checkSetterPreconditions(parameterIndex);
        parameterMetaData_.clientParamtertype_[parameterIndex - 1] = java.sql.Types.LONGVARBINARY;
        if (x == null) {
            setNull(parameterIndex, java.sql.Types.LONGVARBINARY);
            return;