Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ParameterMetaData.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ParameterMetaData.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ParameterMetaData.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ParameterMetaData.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,146 @@
+/*
+
+ Derby - Class org.apache.derby.client.am.ParameterMetaData
+
+ Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors,
where applicable.
+
+ Licensed 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.client.am;
+
+// Parameter meta data as used internally by the driver is always a column
meta data instance.
+// We will only create instances of this class when getParameterMetaData() is
called.
+// This class simply wraps a column meta data instance.
+//
+// Once we go to JDK 1.4 as runtime pre-req, we can extend ColumnMetaData and
new up ParameterMetaData instances directly,
+// and we won't have to wrap column meta data instances directly.
+public class ParameterMetaData implements java.sql.ParameterMetaData
+{
+ ColumnMetaData columnMetaData_;
+
+ // This is false unless for parameterMetaData for a call statement with
return clause
+ boolean escapedProcedureCallWithResult_ = false;
+
+ public ParameterMetaData (ColumnMetaData columnMetaData)
+ {
+ columnMetaData_ = columnMetaData;
+ }
+
+ public int getParameterCount () throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ return columnMetaData_.columns_++;
+ return columnMetaData_.columns_;
+ }
+
+ public int getParameterType (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return java.sql.Types.INTEGER;
+ }
+ return columnMetaData_.getColumnType (param);
+ }
+
+ public String getParameterTypeName (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return "INTEGER";
+ }
+ return columnMetaData_.getColumnTypeName (param);
+ }
+
+ public String getParameterClassName (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return "java.lang.Integer";
+ }
+ return columnMetaData_.getColumnClassName (param);
+ }
+
+ public int getParameterMode (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return java.sql.ParameterMetaData.parameterModeOut;
+ }
+ columnMetaData_.checkForValidColumnIndex (param);
+ if (columnMetaData_.sqlxParmmode_[param - 1] ==
java.sql.ParameterMetaData.parameterModeUnknown)
+ return java.sql.ParameterMetaData.parameterModeUnknown;
+ else if (columnMetaData_.sqlxParmmode_[param - 1] ==
java.sql.ParameterMetaData.parameterModeIn)
+ return java.sql.ParameterMetaData.parameterModeIn;
+ else if (columnMetaData_.sqlxParmmode_[param - 1] ==
java.sql.ParameterMetaData.parameterModeOut)
+ return java.sql.ParameterMetaData.parameterModeOut;
+ else
+ return java.sql.ParameterMetaData.parameterModeInOut;
+ }
+
+ public int isNullable (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return java.sql.ResultSetMetaData.columnNoNulls;
+ }
+ return columnMetaData_.isNullable (param);
+ }
+
+ public boolean isSigned (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return true;
+ }
+ return columnMetaData_.isSigned (param);
+ }
+
+ public int getPrecision (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return 10;
+ }
+ return columnMetaData_.getPrecision (param);
+ }
+
+ public int getScale (int param) throws SqlException
+ {
+ if (escapedProcedureCallWithResult_)
+ {
+ param--;
+ if (param == 0)
+ return 0;
+ }
+ return columnMetaData_.getScale (param);
+ }
+
+}
+
+
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ParameterMetaData.java
------------------------------------------------------------------------------
svn:eol-style = native
Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatement.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatement.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatement.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatement.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,1609 @@
+/*
+
+ Derby - Class org.apache.derby.client.am.PreparedStatement
+
+ Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors,
where applicable.
+
+ Licensed 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.client.am;
+
+import org.apache.derby.client.am.Section;
+
+public class PreparedStatement extends Statement
+ implements java.sql.PreparedStatement,
+ PreparedStatementCallbackInterface
+{
+ //---------------------navigational
cheat-links-------------------------------
+ // Cheat-links are for convenience only, and are not part of the conceptual
model.
+ // Warning:
+ // Cheat-links should only be defined for invariant state data.
+ // That is, the state data is set by the constructor and never changes.
+
+ // Alias for downcast (MaterialPreparedStatementProxy)
super.materialStatement.
+ public MaterialPreparedStatement materialPreparedStatement_ = null;
+
+
//-----------------------------state------------------------------------------
+
+ public String sql_;
+
+ // This variable is only used by Batch.
+ // True if a call sql statement has an OUT or INOUT parameter registered.
+ public boolean outputRegistered_ = false;
+
+ // Parameter inputs are cached as objects so they may be sent on execute()
+ public Object[] parameters_;
+
+ boolean[] parameterSet_;
+ boolean[] parameterRegistered_;
+
+ void setInput (int parameterIndex, Object input)
+ { parameters_[parameterIndex-1] = input; parameterSet_[parameterIndex-1] =
true; }
+
+ public ColumnMetaData parameterMetaData_; // type information for input sqlda
+
+
+ // The problem with storing the scrollable ResultSet associated with
cursorName in scrollableRS_ is
+ // that when the PreparedStatement is re-executed, it has a new ResultSet,
however, we always do
+ // the reposition on the ResultSet that was stored in scrollableRS_, and we
never update scrollableRS_
+ // when PreparedStatement is re-execute. So the new ResultSet that needs to
be repositioned never
+ // gets repositioned.
+ // So instead of caching the scrollableRS_, we will cache the cursorName.
And re-retrieve the scrollable
+ // result set from the map using this cursorName every time the
PreparedStatement excutes.
+ String positionedUpdateCursorName_ = null;
+
+
+ private void initPreparedStatement()
+ {
+ materialPreparedStatement_ = null;
+ sql_ = null;
+ outputRegistered_ = false;
+ parameters_ = null;
+ parameterSet_ = null;
+ parameterRegistered_ = null;
+ parameterMetaData_ = null;
+ isAutoCommittableStatement_ = true;
+ isPreparedStatement_ = true;
+ }
+
+ protected void initResetPreparedStatement()
+ {
+ outputRegistered_ = false;
+ isPreparedStatement_ = true;
+
+ if (parameterMetaData_ != null)
+ resetParameters();
+ }
+
+ public void reset (boolean fullReset) throws SqlException
+ {
+ if (fullReset)
+ connection_.resetPrepareStatement (this);
+ else {
+ super.initResetPreparedStatement();
+ initResetPreparedStatement();
+ }
+ }
+
+ private void resetParameters ()
+ {
+ for (int i = 0; i < parameterMetaData_.columns_; i++) {
+ parameters_[i] = null;
+ parameterSet_[i] = false;
+ parameterRegistered_[i] = false;
+ }
+ }
+
+ // For for JDBC 2 positioned update statements.
+ // Called by material statement constructors.
+ public PreparedStatement (Agent agent,
+ Connection connection,
+ String sql,
+ Section section) throws SqlException
+ {
+ super (agent, connection);
+ initPreparedStatement (sql, section);
+ }
+
+ public void resetPreparedStatement (Agent agent,
+ Connection connection,
+ String sql,
+ Section section) throws SqlException
+ {
+ super.resetStatement(agent, connection);
+ initPreparedStatement();
+ initPreparedStatement (sql, section);
+ }
+
+ private void initPreparedStatement (String sql, Section section) throws
SqlException
+ {
+ sql_ = sql;
+ isPreparedStatement_ = true;
+
+ parseSqlAndSetSqlModes (sql_);
+ section_ = section;
+ }
+
+ // Constructor for jdbc 2 prepared statements with scroll attributes.
+ // Called by material statement constructors.
+ public PreparedStatement (Agent agent,
+ Connection connection,
+ String sql,
+ int type, int concurrency, int holdability, int
autoGeneratedKeys, String[] columnNames) throws SqlException
+ {
+ super (agent, connection, type, concurrency, holdability,
autoGeneratedKeys, columnNames);
+ initPreparedStatement (sql);
+ }
+
+ public void resetPreparedStatement (Agent agent,
+ Connection connection,
+ String sql,
+ int type, int concurrency, int
holdability, int autoGeneratedKeys, String[] columnNames) throws SqlException
+ {
+ super.resetStatement(agent, connection, type, concurrency, holdability,
autoGeneratedKeys, columnNames);
+ initPreparedStatement();
+ initPreparedStatement (sql);
+ }
+
+ private void initPreparedStatement ( String sql) throws SqlException
+ {
+ sql_ = super.escape (sql);
+ parseSqlAndSetSqlModes (sql_);
+ isPreparedStatement_ = true;
+
+ // Check for positioned update statement and assign a section from the
+ // same package as the corresponding query section.
+ // Scan the sql for an "update...where current of <cursor-name>".
+ String cursorName = null;
+ if(sqlUpdateMode_ == isDeleteSql__ || sqlUpdateMode_ == isUpdateSql__) {
+ String[] sqlAndCursorName = extractCursorNameFromWhereCurrentOf (sql_);
+ if(sqlAndCursorName != null) {
+ cursorName = sqlAndCursorName[0];
+ sql_ = sqlAndCursorName[1];
+ }
+ }
+ if (cursorName != null) {
+ positionedUpdateCursorName_ = cursorName;
+ // Get a new section from the same package as the query section
+ section_ = agent_.sectionManager_.getPositionedUpdateSection
(cursorName, false); // false means get a regular section
+
+ if (section_ == null)
+ throw new SqlException (agent_.logWriter_, "Invalid cursor name \"" +
cursorName + "\" in the Update/Delete statement.");
+
+ //scrollableRS_ = agent_.sectionManager_.getPositionedUpdateResultSet
(cursorName);
+
+ // if client's cursor name is set, and the cursor name in the positioned
update
+ // string is the same as the client's cursor name, replace client's
cursor name
+ // with the server's cursor name.
+ // if the cursor name supplied in the sql string is different from the
cursorName
+ // set by setCursorName(), then server will return "cursor name not
defined" error,
+ // and no subsititution is made here.
+ if (section_.getClientCursorName() != null && // cursor name is user
defined
+ cursorName.compareTo (section_.getClientCursorName()) == 0)
+ // client's cursor name is substituted with section's server cursor
name
+ sql_ = substituteClientCursorNameWithServerCursorName (sql_, section_);
+ }
+ else {
+ // We don't need to analyze the sql text to determine if it is a query
or not.
+ // This is up to the server to decide, we just pass thru the sql on
flowPrepare().
+ section_ = agent_.sectionManager_.getDynamicSection
(resultSetHoldability_);
+ }
+ }
+
+ public void resetPreparedStatement (Agent agent,
+ Connection connection,
+ String sql,
+ Section section,
+ ColumnMetaData parameterMetaData,
+ ColumnMetaData resultSetMetaData) throws
SqlException
+ {
+ resetPreparedStatement (agent, connection, sql, section);
+ initPreparedStatement (parameterMetaData, resultSetMetaData);
+ }
+
+ private void initPreparedStatement (
+ ColumnMetaData parameterMetaData,
+ ColumnMetaData resultSetMetaData) throws
SqlException
+ {
+ isPreparedStatement_ = true;
+ parameterMetaData_ = parameterMetaData;
+ resultSetMetaData_ = resultSetMetaData;
+ if(parameterMetaData_ != null) {
+ parameters_ = new Object[parameterMetaData_.columns_];
+ //parameterSetOrRegistered_ = new boolean[parameterMetaData_.columns_];
+ parameterSet_ = new boolean[parameterMetaData_.columns_];
+ parameterRegistered_ = new boolean[parameterMetaData_.columns_];
+ }
+ }
+
+ protected void finalize () throws java.lang.Throwable
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"finalize");
+ if (openOnClient_) {
+ synchronized (connection_) {
+ closeX();
+ }
+ }
+ super.finalize();
+ }
+
+ // called immediately after the constructor by Connection prepare*() methods
+ void prepare () throws SqlException
+ {
+ try {
+ // flow prepare, no static initialization is needed
+ // already checked if columnNames is not null and server supports
select from insert
+ // in prepareStatementX()
+ if (sqlUpdateMode_ == isInsertSql__ && generatedKeysColumnNames_ !=
null)
+ flowPrepareForSelectFromInsert ();
+ else
+ flowPrepareDescribeInputOutput();
+ }
+ catch (SqlException e) {
+ this.markClosed();
+ throw e;
+ }
+ }
+
+
+ //------------------- Prohibited overrides from Statement
--------------------
+
+ public boolean execute (String sql) throws SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"execute", sql);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.execute (String sql) cannot be called on
a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.execute () with no sql string
argument.");
+ }
+
+ public java.sql.ResultSet executeQuery (String sql) throws SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeQuery", sql);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.executeQuery (String sql) cannot be
called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.executeQuery () with no sql string
argument.");
+ }
+
+ public int executeUpdate (String sql) throws SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeUpdate", sql);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.executeUpdate (String sql) cannot be
called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.executeUpdate () with no sql string
argument.");
+ }
+ // ---------------------------jdbc
1------------------------------------------
+
+ public java.sql.ResultSet executeQuery () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeQuery");
+ ResultSet resultSet = executeQueryX();
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceExit (this,
"executeQuery", resultSet);
+ return resultSet;
+ }
+ }
+
+ // also called by some DBMD methods
+ ResultSet executeQueryX () throws SqlException
+ {
+ flowExecute (executeQueryMethod__);
+
+ super.checkExecuteQueryPostConditions ("java.sql.PreparedStatement");
+ return resultSet_;
+ }
+
+
+ public int executeUpdate () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeUpdate");
+ int updateValue = executeUpdateX();
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceExit (this,
"executeUpdate", updateValue);
+ return updateValue;
+ }
+ }
+
+ // also used by Blob
+ 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; }
+ setInput(parameterIndex, x);
+
+ }
+
+ public void setBinaryStream (int parameterIndex,
+ java.io.InputStream x,
+ int length) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setBinaryStream", parameterIndex, "<input stream>", length);
+ setBinaryStreamX (parameterIndex, x, length);
+ }
+ }
+
+ public void setBinaryStreamX (int parameterIndex,
+ java.io.InputStream x,
+ int length) throws SqlException
+ {
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ parameterMetaData_.clientParamtertype_[parameterIndex -1] =
java.sql.Types.BLOB;
+ if (x == null) { setNull (parameterIndex, java.sql.Types.BLOB); return; }
+ setInput(parameterIndex, new Blob (agent_, x, length));
+ }
+
+ public void setAsciiStream (int parameterIndex,
+ java.io.InputStream x,
+ int length) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setAsciiStream", parameterIndex, "<input stream>", length);
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ parameterMetaData_.clientParamtertype_[parameterIndex -1] =
java.sql.Types.CLOB;
+ if (x == null) { setNull (parameterIndex, java.sql.Types.CLOB); return; }
+ setInput(parameterIndex, new Clob (agent_, x, "US-ASCII", length));
+ }
+ }
+
+ public void setUnicodeStream (int parameterIndex,
+ java.io.InputStream x,
+ int length) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceDeprecatedEntry
(this, "setUnicodeStream", parameterIndex, "<input stream>", length);
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ parameterMetaData_.clientParamtertype_[parameterIndex -1] =
java.sql.Types.CLOB;
+ if (x == null) { setNull (parameterIndex, java.sql.Types.CLOB); return; }
+ setInput(parameterIndex, new Clob (agent_, x, "UnicodeBigUnmarked",
length));
+ }
+ }
+
+ public void setCharacterStream (int parameterIndex,
+ java.io.Reader x,
+ int length) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setCharacterStream", parameterIndex, x, length);
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ parameterMetaData_.clientParamtertype_[parameterIndex -1] =
java.sql.Types.CLOB;
+ if (x == null) { setNull (parameterIndex, java.sql.Types.CLOB); return; }
+ setInput(parameterIndex, new Clob (agent_, x, length));
+ }
+ }
+
+ public void setBlob (int parameterIndex, java.sql.Blob x) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setBlob", parameterIndex, x);
+ setBlobX (parameterIndex, x);
+ }
+ }
+
+ // also used by Blob
+ public void setBlobX (int parameterIndex, java.sql.Blob x) throws
SqlException
+ {
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ parameterMetaData_.clientParamtertype_[parameterIndex -1] =
java.sql.Types.BLOB;
+ if (x == null) { setNull (parameterIndex, java.sql.Types.BLOB); return; }
+ setInput(parameterIndex, x);
+ }
+
+ public void setClob (int parameterIndex, java.sql.Clob x) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setClob", parameterIndex, x);
+ setClobX (parameterIndex, x);
+ }
+ }
+
+ // also used by Clob
+ void setClobX (int parameterIndex, java.sql.Clob x) throws SqlException
+ {
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ parameterMetaData_.clientParamtertype_[parameterIndex -1] =
java.sql.Types.CLOB;
+ if (x == null) { this.setNullX (parameterIndex, Types.CLOB); return; }
+ setInput(parameterIndex, x);
+ }
+
+
+ public void setArray (int parameterIndex, java.sql.Array x) throws
SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setArray", parameterIndex, x);
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ throw new SqlException (agent_.logWriter_, "jdbc 2 method not yet
implemented");
+ }
+ }
+
+ public void setRef (int parameterIndex, java.sql.Ref x) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setRef", parameterIndex, x);
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ throw new SqlException (agent_.logWriter_, "jdbc 2 method not yet
implemented");
+ }
+ }
+
+ // The Java compiler uses static binding, so we must use instanceof
+ // rather than to rely on separate setObject() methods for
+ // each of the Java Object instance types recognized below.
+ public void setObject (int parameterIndex, Object x) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setObject", parameterIndex, x);
+ super.checkForClosedStatement();
+ if (x instanceof String) setString (parameterIndex,
(String) x);
+ else if (x instanceof Integer) setInt (parameterIndex,
((Integer) x).intValue());
+ else if (x instanceof Double) setDouble (parameterIndex,
((Double) x).doubleValue());
+ else if (x instanceof Float) setFloat (parameterIndex,
((Float) x).floatValue());
+ else if (x instanceof Boolean) setBoolean (parameterIndex,
((Boolean) x).booleanValue());
+ else if (x instanceof Long) setLong (parameterIndex,
((Long) x).longValue());
+ else if (x instanceof byte[]) setBytes (parameterIndex,
(byte[]) x);
+ else if (x instanceof java.math.BigDecimal) setBigDecimal
(parameterIndex, (java.math.BigDecimal) x);
+ else if (x instanceof java.sql.Date) setDate (parameterIndex,
(java.sql.Date) x);
+ else if (x instanceof java.sql.Time) setTime (parameterIndex,
(java.sql.Time) x);
+ else if (x instanceof java.sql.Timestamp) setTimestamp
(parameterIndex, (java.sql.Timestamp) x);
+ else if (x instanceof java.sql.Blob) setBlob (parameterIndex,
(java.sql.Blob) x);
+ else if (x instanceof java.sql.Clob) setClob (parameterIndex,
(java.sql.Clob) x);
+ else if (x instanceof java.sql.Array) setArray (parameterIndex,
(java.sql.Array) x);
+ else if (x instanceof java.sql.Ref) setRef (parameterIndex,
(java.sql.Ref) x);
+ else if (x instanceof Short) setShort (parameterIndex,
((Short) x).shortValue());
+ else if (x instanceof Byte) setByte (parameterIndex,
((Byte) x).byteValue());
+ else {
+ checkSetterPreconditions (parameterIndex);
+ throw new SqlException (agent_.logWriter_, "Invalid data conversion:" +
+ " Parameter object type is invalid for requested
conversion.");
+ }
+ }
+ }
+
+ public void setObject (int parameterIndex, Object x, int targetJdbcType)
throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setObject", parameterIndex, x, targetJdbcType);
+ setObjectX (parameterIndex, x, targetJdbcType, 0);
+ }
+ }
+
+ public void setObject (int parameterIndex,
+ Object x,
+ int targetJdbcType,
+ int scale) throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"setObject", parameterIndex, x, targetJdbcType, scale);
+ setObjectX (parameterIndex, x, targetJdbcType, scale);
+ }
+ }
+
+ private void setObjectX (int parameterIndex,
+ Object x,
+ int targetJdbcType,
+ int scale) throws SqlException
+ {
+ parameterIndex = checkSetterPreconditions (parameterIndex);
+ checkForValidScale (scale);
+
+ if (x == null) { setNull (parameterIndex, targetJdbcType); return; }
+ setObject(parameterIndex, x);
+ }
+
+ // Since parameters are cached as objects in parameters_[],
+ // java null may be used to represent SQL null.
+ public void clearParameters () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled ()) agent_.logWriter_.traceEntry (this,
"clearParameters");
+ checkForClosedStatement ();
+ if (parameterMetaData_ != null) {
+ for (int i = 0; i < parameters_.length; i++)
+ parameters_[i] = null;
+
+ for (int i = 0; i < parameterSet_.length; i++)
+ parameterSet_[i] = false;
+ }
+ }
+ }
+
+ public boolean execute () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"execute");
+ boolean b = executeX();
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceExit (this,
"execute", b);
+ return b;
+ }
+ }
+
+ private boolean executeX () throws SqlException
+ {
+ flowExecute (executeMethod__);
+
+ return resultSet_ != null;
+ }
+
+ //--------------------------JDBC 2.0-----------------------------
+
+ public void addBatch () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"addBatch");
+ checkForClosedStatement ();
+ checkThatAllParametersAreSet();
+
+ // ASSERT: since OUT/INOUT parameters are not allowed, there should
+ // be no problem in sharing the JDBC Wrapper object instances
+ // since they will not be modified by the driver.
+
+ // batch up the parameter values -- deep copy req'd
+
+ if(parameterMetaData_ != null) {
+ Object[] inputsClone = new Object[parameters_.length];
+ System.arraycopy (parameters_, 0, inputsClone, 0, parameters_.length);
+
+ batch_.add (inputsClone);
+ }
+ else
+ batch_.add(null);
+ }
+ }
+
+ // Batch requires that input types are exact, we perform no input cross
conversion for Batch.
+ // If so, this is an external semantic, and should go into the release notes
+ public int[] executeBatch() throws SqlException, BatchUpdateException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeBatch");
+ int[] updateCounts = null;
+ updateCounts = executeBatchX (false);
+
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceExit (this,
"executeBatch", updateCounts);
+ return updateCounts;
+ }
+ }
+
+ public java.sql.ResultSetMetaData getMetaData () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"getMetaData");
+ ColumnMetaData resultSetMetaData = getMetaDataX();
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceExit (this,
"getMetaData", resultSetMetaData);
+ return resultSetMetaData;
+ }
+ }
+
+ private ColumnMetaData getMetaDataX () throws SqlException
+ {
+ super.checkForClosedStatement();
+ return resultSetMetaData_;
+ }
+
+ //------------------------- JDBC 3.0 -----------------------------------
+
+ public boolean execute (String sql, int autoGeneratedKeys) throws
SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"execute", sql, autoGeneratedKeys);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.execute (String sql, int
autoGeneratedKeys) cannot be called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.execute () with no arguments.");
+ }
+
+ public boolean execute (String sql, String[] columnNames) throws SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"execute", sql, columnNames);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.execute (String sql, String[]
columnNames) cannot be called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.execute () with no arguments.");
+ }
+
+ public boolean execute (String sql, int[] columnIndexes) throws SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"execute", sql, columnIndexes);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.execute (String sql, int[] columnIndexes)
cannot be called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.execute () with no arguments.");
+ }
+
+ public int executeUpdate (String sql, int autoGeneratedKeys) throws
SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeUpdate", autoGeneratedKeys);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.executeUpdate (String sql, int
autoGeneratedKeys) cannot be called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.executeUpdate () with no arguments.");
+ }
+
+ public int executeUpdate (String sql, String[] columnNames) throws
SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeUpdate", columnNames);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.executeUpdate (String sql, String[]
columnNames) cannot be called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.executeUpdate () with no arguments.");
+ }
+
+ public int executeUpdate (String sql, int[] columnIndexes) throws
SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"executeUpdate", columnIndexes);
+ throw new SqlException (agent_.logWriter_,
+ "The method java.sql.Statement.executeUpdate (String sql, int[]
columnIndexes) cannot be called on a " +
+ " prepared statement instance." +
+ " Use java.sql.PreparedStatement.executeUpdate () with no arguments.");
+ }
+
+ public void setURL (int parameterIndex, java.net.URL x) throws SqlException
+ {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this, "setURL",
parameterIndex, x);
+ throw new SqlException (agent_.logWriter_, "JDBC 3 method called - not yet
supported");
+ }
+
+ public java.sql.ParameterMetaData getParameterMetaData() throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"getParameterMetaData");
+ Object parameterMetaData = getParameterMetaDataX();
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceExit (this,
"getParameterMetaData", parameterMetaData);
+ return (java.sql.ParameterMetaData) parameterMetaData;
+ }
+ }
+
+ private ParameterMetaData getParameterMetaDataX() throws SqlException
+ {
+ super.checkForClosedStatement();
+ ParameterMetaData pm = new ParameterMetaData (parameterMetaData_ != null
+ ? parameterMetaData_
+ : new ColumnMetaData(agent_.logWriter_, 0));
+ if (escapedProcedureCallWithResult_)
+ pm.escapedProcedureCallWithResult_ = true;
+ return pm;
+ }
+
+ // ------------------------ box car and callback methods
--------------------------------
+
+ public void writeExecute (Section section,
+ ColumnMetaData parameterMetaData,
+ Object[] inputs,
+ int numInputColumns,
+ boolean outputExpected,
+ // This is a hint to the material layer that more
write commands will follow.
+ // It is ignored by the driver in all cases except
when blob data is written,
+ // in which case this boolean is used to optimize
the implementation.
+ // Otherwise we wouldn't be able to chain after
blob data is sent.
+ // Current servers have a restriction that blobs
can only be chained with blobs
+ boolean chainedWritesFollowingSetLob
+ ) throws SqlException
+ { materialPreparedStatement_.writeExecute_ (section,
+ parameterMetaData,
+ inputs,
+ numInputColumns,
+ outputExpected,
+ chainedWritesFollowingSetLob);
+ }
+
+
+ public void readExecute () throws SqlException
+ { materialPreparedStatement_.readExecute_(); }
+
+ public void writeOpenQuery (Section section,
+ int fetchSize,
+ int resultSetType,
+ int numInputColumns,
+ ColumnMetaData parameterMetaData,
+ Object[] inputs
+ ) throws SqlException
+ { materialPreparedStatement_.writeOpenQuery_ (section,
+ fetchSize,
+ resultSetType,
+ numInputColumns,
+ parameterMetaData,
+ inputs);}
+ public void writeDescribeInput (Section section) throws SqlException
+ { materialPreparedStatement_.writeDescribeInput_ (section); }
+ public void readDescribeInput () throws SqlException
+ { materialPreparedStatement_.readDescribeInput_(); }
+
+ public void completeDescribeInput (ColumnMetaData parameterMetaData, Sqlca
sqlca)
+ {
+ int sqlcode = super.completeSqlca (sqlca);
+ if (sqlcode < 0) return;
+
+
+ parameterMetaData_ = parameterMetaData;
+
+ // The following code handles the case when
+ // sqlxParmmode is not supported, in which case server will return 0
(unknown), and
+ // this could clobber our guessed value for sqlxParmmode. This is a
problem.
+ // We can solve this problem for Non-CALL statements, since the parmmode
is always IN (1).
+ // But what about CALL statements. If CALLs are describable, then we have
no
+ // problem, we assume server won't return unknown.
+ // If CALLs are not describable then nothing gets clobbered because we
won't
+ // parse out extended describe, so again no problem.
+ if (sqlMode_ != isCall__ && parameterMetaData_ != null)
+ for (int i = 0; i < parameterMetaData_.columns_; i++)
+ parameterMetaData_.sqlxParmmode_[i] = 1; // 1 means IN parameter
+
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceParameterMetaData
(this, parameterMetaData_);
+ }
+
+ public void writeDescribeOutput (Section section) throws SqlException
+ { materialPreparedStatement_.writeDescribeOutput_ (section); }
+ public void readDescribeOutput () throws SqlException
+ { materialPreparedStatement_.readDescribeOutput_(); }
+ public void completeDescribeOutput (ColumnMetaData resultSetMetaData, Sqlca
sqlca)
+ {
+ int sqlcode = super.completeSqlca (sqlca);
+ if (sqlcode < 0) return;
+ resultSetMetaData_ = resultSetMetaData;
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceResultSetMetaData
(this, resultSetMetaData);
+ }
+
+ void writePrepareDescribeInputOutput () throws SqlException
+ {
+ // Notice that sql_ is passed in since in general ad hoc sql must be
passed in for unprepared statements
+ writePrepareDescribeOutput (sql_, section_);
+ writeDescribeInput (section_);
+ }
+
+ void readPrepareDescribeInputOutput () throws SqlException
+ {
+ readPrepareDescribeOutput ();
+ readDescribeInput ();
+ completePrepareDescribe();
+ }
+
+ void writePrepareDescribeInput () throws SqlException
+ {
+ // performance will be better if we flow prepare with output enable vs.
prepare then describe input for callable
+ // Notice that sql_ is passed in since in general ad hoc sql must be
passed in for unprepared statements
+ writePrepare (sql_, section_);
+ writeDescribeInput (section_);
+ }
+
+ void readPrepareDescribeInput () throws SqlException
+ {
+ readPrepare();
+ readDescribeInput ();
+ completePrepareDescribe();
+ }
+
+ void completePrepareDescribe ()
+ {
+ if (parameterMetaData_ == null) return;
+ parameters_ = expandObjectArray (parameters_, parameterMetaData_.columns_);
+ parameterSet_ = expandBooleanArray (parameterSet_,
parameterMetaData_.columns_);
+ parameterRegistered_ = expandBooleanArray (parameterRegistered_,
parameterMetaData_.columns_);
+ }
+
+ private Object[] expandObjectArray (Object[] array, int newLength)
+ {
+ if (array == null) {
+ Object[] newArray = new Object[newLength];
+ return newArray;
+ }
+ if (array.length < newLength) {
+ Object[] newArray = new Object[newLength];
+ System.arraycopy (array, 0, newArray, 0, array.length);
+ return newArray;
+ }
+ return array;
+ }
+
+ private boolean[] expandBooleanArray (boolean[] array, int newLength)
+ {
+ if (array == null) {
+ boolean[] newArray = new boolean[newLength];
+ return newArray;
+ }
+ if (array.length < newLength) {
+ boolean[] newArray = new boolean[newLength];
+ System.arraycopy (array, 0, newArray, 0, array.length);
+ return newArray;
+ }
+ return array;
+ }
+
+ void flowPrepareForSelectFromInsert () throws SqlException
+ {
+ agent_.beginWriteChain (this);
+ writePrepareDescribeInputOutput (constructSelectFromInsertSQL(sql_),
section_);
+ agent_.flow (this);
+ readPrepareDescribeInputOutput();
+ agent_.endReadChain();
+ }
+
+ void writePrepareDescribeInputOutput (String sql,
+ Section section) throws SqlException
+ {
+ // Notice that sql_ is passed in since in general ad hoc sql must be
passed in for unprepared statements
+ writePrepareDescribeOutput (sql, section);
+ writeDescribeInput (section);
+ }
+
+ void flowPrepareDescribeInputOutput () throws SqlException
+ {
+ agent_.beginWriteChain (this);
+ if (sqlMode_ == isCall__) {
+ writePrepareDescribeInput();
+ agent_.flow (this);
+ readPrepareDescribeInput();
+ agent_.endReadChain();
+ }
+ else {
+ writePrepareDescribeInputOutput();
+ agent_.flow (this);
+ readPrepareDescribeInputOutput();
+ agent_.endReadChain();
+ }
+ }
+
+ void flowExecute (int executeType) throws SqlException
+ {
+ super.checkForClosedStatement();
+ super.clearWarningsX();
+ super.checkForAppropriateSqlMode (executeType, sqlMode_);
+ checkThatAllParametersAreSet();
+
+ if (sqlMode_ == isUpdate__) updateCount_ = 0;
+ else updateCount_ = -1;
+
+ java.util.Timer queryTimer = null;
+ QueryTimerTask queryTimerTask = null;
+ if (timeout_ != 0) {
+ queryTimer = new java.util.Timer (); // A thread that ticks the seconds
+ queryTimerTask = new QueryTimerTask (this, queryTimer);
+ queryTimer.schedule (queryTimerTask, 1000*timeout_);
+ }
+
+ try {
+ agent_.beginWriteChain (this);
+
+ boolean piggybackedAutocommit = super.writeCloseResultSets (true); //
true means permit auto-commits
+
+
+ int numInputColumns = (parameterMetaData_ != null) ?
parameterMetaData_.getColumnCount() : 0;
+ boolean outputExpected = (resultSetMetaData_ != null &&
resultSetMetaData_.getColumnCount() > 0);
+ boolean chainAutoCommit = false;
+ boolean commitSubstituted = false;
+ boolean repositionedCursor = false;
+ ResultSet scrollableRS = null;
+
+ switch (sqlMode_) {
+ case isUpdate__:
+ if (positionedUpdateCursorName_ != null)
+ scrollableRS = agent_.sectionManager_.getPositionedUpdateResultSet
(positionedUpdateCursorName_);
+ if (scrollableRS != null && !scrollableRS.isRowsetCursor_) {
+ repositionedCursor =
+
scrollableRS.repositionScrollableResultSetBeforeJDBC1PositionedUpdateDelete();
+ if (!repositionedCursor) scrollableRS = null;
+ }
+
+ chainAutoCommit = connection_.willAutoCommitGenerateFlow() &&
isAutoCommittableStatement_;
+
+ if (sqlUpdateMode_ == isInsertSql__ && generatedKeysColumnNames_ !=
null) {
+ writeOpenQuery (section_,
+ fetchSize_,
+ resultSetType_,
+ numInputColumns,
+ parameterMetaData_,
+ parameters_);
+ }
+ else {
+ boolean chainOpenQueryForAutoGeneratedKeys = (sqlUpdateMode_ ==
isInsertSql__ && autoGeneratedKeys_ == RETURN_GENERATED_KEYS);
+ writeExecute (section_,
+ parameterMetaData_,
+ parameters_,
+ numInputColumns,
+ outputExpected,
+ (chainAutoCommit ||
chainOpenQueryForAutoGeneratedKeys)// chain flag
+ ); // chain flag
+
+ if (chainOpenQueryForAutoGeneratedKeys) {
+ prepareAutoGeneratedKeysStatement ();
+ writeOpenQuery (preparedStatementForAutoGeneratedKeys_.section_,
+ preparedStatementForAutoGeneratedKeys_.fetchSize_,
+
preparedStatementForAutoGeneratedKeys_.resultSetType_);
+ }
+ }
+
+ if (chainAutoCommit) {
+ // we have encountered an error in writing the execute, so do not
+ // flow an autocommit
+ if (agent_.accumulatedReadExceptions_ != null) {
+ // currently, the only write exception we encounter is for
+ // data truncation: SQLSTATE 01004, so we don't bother checking
for this
+ connection_.writeCommitSubstitute_ ();
+ commitSubstituted = true;
+ }
+ else {
+ // there is no write error, so flow the commit
+ connection_.writeCommit ();
+ }
+ }
+ break;
+
+ case isQuery__:
+ writeOpenQuery (section_,
+ fetchSize_,
+ resultSetType_,
+ numInputColumns,
+ parameterMetaData_,
+ parameters_);
+ break;
+
+ case isCall__:
+ writeExecuteCall (outputRegistered_, // if no out/inout parameter,
outputExpected = false
+ null,
+ section_,
+ fetchSize_,
+ false, // do not suppress ResultSets for regular
CALLs
+ resultSetType_,
+ parameterMetaData_,
+ parameters_); // cross conversion
+ break;
+ }
+
+ agent_.flow (this);
+
+ super.readCloseResultSets (true); // true means permit auto-commits
+
+ // turn inUnitOfWork_ flag back on and add statement
+ // back on commitListeners_ list if they were off
+ // by an autocommit chained to a close cursor.
+ if (piggybackedAutocommit) {
+ connection_.completeTransactionStart();
+ }
+
+ super.markResultSetsClosed();
+
+ switch (sqlMode_) {
+ case isUpdate__:
+ // do not need to reposition for a rowset cursor
+ if (scrollableRS != null && !scrollableRS.isRowsetCursor_)
+ scrollableRS.readPositioningFetch_();
+
+ if (sqlUpdateMode_ == isInsertSql__ && generatedKeysColumnNames_ !=
null) {
+ readOpenQuery ();
+ if (resultSet_ != null) {
+ generatedKeysResultSet_ = resultSet_;
+ resultSet_ = null;
+ updateCount_ = 1;
+ }
+ }
+ else {
+ readExecute ();
+
+ if (sqlUpdateMode_ == isInsertSql__ && autoGeneratedKeys_ ==
RETURN_GENERATED_KEYS) {
+ readPrepareAutoGeneratedKeysStatement ();
+ preparedStatementForAutoGeneratedKeys_.readOpenQuery ();
+ generatedKeysResultSet_ =
preparedStatementForAutoGeneratedKeys_.resultSet_;
+ preparedStatementForAutoGeneratedKeys_.resultSet_ = null;
+ }
+ }
+
+ if (chainAutoCommit) {
+ if (commitSubstituted)
+ connection_.readCommitSubstitute_ ();
+ else
+ connection_.readCommit ();
+ }
+ break;
+
+ case isQuery__:
+ try {
+ readOpenQuery ();
+ }
+ catch (DisconnectException dise ) {
+ throw dise;
+ }
+ catch (SqlException e) {
+ throw e;
+ }
+ // resultSet_ is null if open query failed.
+ // check for null resultSet_ before using it.
+ if (resultSet_ != null) {
+ resultSet_.parseScrollableRowset ();
+ //if (resultSet_.scrollable_) resultSet_.getRowCount();
+ // If client's cursor name is set, map the client's cursor name to
the ResultSet
+ // Else map the server's cursor name to the ResultSet
+ mapCursorNameToResultSet ();
+ }
+ break;
+
+ case isCall__:
+ readExecuteCall();
+ break;
+
+ }
+
+
+ try {
+ agent_.endReadChain();
+ }
+ catch (SqlException e) {
+ throw e;
+
+ }
+
+ if (sqlMode_ == isCall__) {
+ parseStorProcReturnedScrollableRowset ();
+ // When there are no result sets back, we will commit
immediately when autocommit is true.
+ // make sure a commit is not performed when making the call to the sqlca
message procedure
+ if (connection_.autoCommit_ && resultSet_ == null &&
resultSetList_ == null && isAutoCommittableStatement_) {
+ connection_.flowAutoCommit();
+ }
+ }
+
+ // Throw an exception if holdability returned by the server is different
from requested.
+ if (resultSet_ != null && resultSet_.resultSetHoldability_ !=
resultSetHoldability_ && sqlMode_ != isCall__)
+ throw new SqlException (agent_.logWriter_, "Unable to open resultSet
with requested " +
+ "holdability " + resultSetHoldability_ + ".");
+
+ }
+ finally {
+ if (timeout_ != 0) { // query timers need to be cancelled.
+ queryTimer.cancel();
+ queryTimerTask.cancel();
+ }
+ }
+
+ }
+
+ public int[] executeBatchX (boolean supportsQueryBatchRequest) throws
SqlException, BatchUpdateException
+ {
+ synchronized (connection_) {
+ checkForClosedStatement (); // Per jdbc spec (see Statement.close()
javadoc)
+ clearWarningsX (); // Per jdbc spec 0.7, also see getWarnings() javadoc
+ return executeBatchRequestX (supportsQueryBatchRequest);
+ }
+ }
+
+
+ private int[] executeBatchRequestX (boolean supportsQueryBatchRequest)
+ throws SqlException, BatchUpdateException
+ {
+ SqlException chainBreaker = null;
+ int batchSize = batch_.size();
+ int[] updateCounts = new int[batchSize];
+ int numInputColumns = parameterMetaData_== null ? 0 :
parameterMetaData_.getColumnCount();
+ Object[] savedInputs = null; // used to save/restore existing parameters
+
+ if (batchSize == 0) return updateCounts;
+
+ // Initialize all the updateCounts to indicate failure
+ // This is done to account for "chain-breaking" errors where we cannot
+ // read any more replies
+ for (int i = 0; i < batchSize; i++)
+ updateCounts[i] = -3;
+
+ if (!supportsQueryBatchRequest && sqlMode_ == isQuery__)
+ throw new BatchUpdateException (agent_.logWriter_, "Batching of queries
not allowed by J2EE compliance", updateCounts);
+ if (supportsQueryBatchRequest && sqlMode_ != isQuery__)
+ throw new BatchUpdateException (agent_.logWriter_, "Query batch
requested on a non-query statement", updateCounts);
+
+ resultSetList_ = null;
+
+
+ if (sqlMode_ == isQuery__) {
+ indexOfCurrentResultSet_ = -1; //reset ResultSetList
+ resultSetList_ = new ResultSet[batchSize];
+ }
+
+
+ //save the current input set so it can be restored
+ savedInputs = parameters_;
+
+ agent_.beginBatchedWriteChain (this);
+ boolean chainAutoCommit = connection_.willAutoCommitGenerateFlow() &&
isAutoCommittableStatement_;
+
+ for (int i = 0; i < batchSize; i++) {
+ parameters_ = (Object[]) batch_.get (i);
+
+ if (sqlMode_ != isCall__) {
+ boolean outputExpected = (resultSetMetaData_ != null &&
resultSetMetaData_.getColumnCount() > 0);
+
+ writeExecute (section_,
+ parameterMetaData_,
+ parameters_,
+ numInputColumns,
+ outputExpected,
+ chainAutoCommit || (i != batchSize - 1)); // more
statements to chain
+ }
+ else if (outputRegistered_) // make sure no output parameters are
registered
+ throw new BatchUpdateException (agent_.logWriter_, "No output
parameters are allowed in batch updates", updateCounts);
+ else {
+ writeExecuteCall (false, // no output expected for batched CALLs
+ null, // no procedure name supplied for
prepared CALLs
+ section_,
+ fetchSize_,
+ true, // suppress ResultSets for batch
+ resultSetType_,
+ parameterMetaData_,
+ parameters_);
+ }
+ }
+
+ boolean commitSubstituted = false;
+ if (chainAutoCommit) {
+ // we have encountered an error in writing the execute, so do not
+ // flow an autocommit
+ if (agent_.accumulatedReadExceptions_ != null) {
+ // currently, the only write exception we encounter is for
+ // data truncation: SQLSTATE 01004, so we don't bother checking for
this
+ connection_.writeCommitSubstitute_ ();
+ commitSubstituted = true;
+ }
+ else {
+ // there is no write error, so flow the commit
+ connection_.writeCommit ();
+ }
+ }
+
+ agent_.flowBatch (this, batchSize);
+
+ try {
+ for (int i = 0; i < batchSize; i++) {
+ agent_.setBatchedExceptionLabelIndex (i);
+ parameters_ = (Object[]) batch_.get (i);
+ if (sqlMode_ != isCall__)
+ readExecute();
+ else
+ readExecuteCall();
+ updateCounts[i] = updateCount_;
+
+ }
+
+ agent_.disableBatchedExceptionTracking(); // to prvent the following
readCommit() from getting a batch label
+ if (chainAutoCommit) {
+ if (!commitSubstituted) {
+ connection_.readCommit ();
+ }
+ else {
+ connection_.readCommitSubstitute_ ();
+ }
+ }
+ }
+
+ // for chain-breaking exception only, all read() methods do their own
accumulation
+ // this catches the entire accumulated chain, we need to be careful not to
+ // reaccumulate it on the agent since the batch labels will be overwritten
if
+ // batch exception tracking is enabled.
+ catch (SqlException e) { // for chain-breaking exception only
+ chainBreaker = e;
+ chainBreaker.setNextException (new SqlException (agent_.logWriter_,
+ "Non-recoverable chain-breaking exception occurred during batch
processing. " +
+ "The batch is terminated non-atomically."));
+ }
+ // We need to clear the batch before any exception is thrown from
agent_.endBatchedReadChain().
+ batch_.clear ();
+
+ // restore the saved input set, setting it to "current"
+ parameters_ = savedInputs;
+
+ agent_.endBatchedReadChain (updateCounts, chainBreaker);
+
+ return updateCounts;
+
+ }
+
+
+ //------------------material layer event callbacks
follow-----------------------
+
+ boolean listenToUnitOfWork_ = false;
+
+ public void listenToUnitOfWork()
+ {
+ if (!listenToUnitOfWork_) {
+ listenToUnitOfWork_ = true;
+ connection_.CommitAndRollbackListeners_.add(this);
+ }
+ }
+
+ public void completeLocalCommit (java.util.Iterator listenerIterator)
+ {
+ if (section_ != null ) openOnServer_ = false;
+ listenerIterator.remove();
+ listenToUnitOfWork_ = false;
+ }
+
+ public void completeLocalRollback (java.util.Iterator listenerIterator)
+ {
+ if (section_ != null ) openOnServer_ = false;
+ listenerIterator.remove();
+ listenToUnitOfWork_ = false;
+ }
+
+ //----------------------------internal use only helper
methods----------------
+
+ private int checkSetterPreconditions (int parameterIndex) throws SqlException
+ {
+ super.checkForClosedStatement();
+ parameterIndex = checkForEscapedCallWithResult (parameterIndex);
+ checkForValidParameterIndex (parameterIndex);
+ return parameterIndex;
+ }
+
+ void checkForValidParameterIndex (int parameterIndex) throws SqlException
+ {
+ if (parameterMetaData_ == null || parameterIndex < 1 || parameterIndex >
parameterMetaData_.columns_)
+ throw new SqlException (agent_.logWriter_, "Invalid argument: parameter
index " +
+ parameterIndex + " is out of range.");
+ }
+
+ private void checkThatAllParametersAreSet () throws SqlException
+ {
+ if (parameterMetaData_ != null) {
+ for (int i = 0; i < parameterMetaData_.columns_; i++)
+ if (!parameterSet_[i] && !parameterRegistered_[i])
+ throw new SqlException (agent_.logWriter_, "At least one parameter
to the current statement is uninitialized.", "07000");
+ }
+ }
+
+
+ private int checkForEscapedCallWithResult (int parameterIndex) throws
SqlException
+ {
+ if (escapedProcedureCallWithResult_) {
+ if (parameterIndex == 1)
+ throw new SqlException (agent_.logWriter_,
+ "Invalid attempt to set the return value parameter of a CALL
statement." +
+ "Return value parameter of {?=CALL foo(?,?)} statement is parameter
1.");
+ else
+ parameterIndex--;
+ }
+ return parameterIndex;
+ }
+
+ void checkForValidScale (int scale) throws SqlException
+ {
+ if (scale < 0 || scale > 31)
+ throw new SqlException (agent_.logWriter_, "Invalid argument: scale must
be greater than or equal to 0 and less than 32.");
+ }
+
+ void checkScaleForINOUTDecimal (int parameterIndex, int registerOutScale)
throws SqlException
+ {
+ java.math.BigDecimal decimalInput = (java.math.BigDecimal)
parameters_[parameterIndex - 1];
+ if (decimalInput == null) return;
+ // if the register out scale is greater than input scale, input scale is
stored in sqlScale_
+ if (registerOutScale > parameterMetaData_.sqlScale_[parameterIndex - 1]) {
+ int inputLength = decimalInput.toString().length();
+ int scaleDifference = registerOutScale - decimalInput.scale();
+ if (decimalInput.signum() == -1) {
+ inputLength--;
+ }
+ // if the new Decimal (with bigger scale) cannot fit into the DA
+ if ((32 - scaleDifference) < inputLength) {
+ throw new SqlException (agent_.logWriter_, "The scale supplied by the
registerOutParameter method does " +
+ "not match with the setter method. Possible
loss of precision!");
+ }
+ // if the new Decimal (with bigger scale) can fit
+ else {
+ parameters_[parameterIndex - 1] = decimalInput.setScale
(registerOutScale);
+ parameterMetaData_.sqlScale_[parameterIndex - 1] = registerOutScale;
+ }
+ }
+ // if the register out sacle is smaller than input scale
+ else if (registerOutScale < parameterMetaData_.sqlScale_[parameterIndex -
1]) {
+ // remove 0's at the end of input
+ try {
+ // if the new Decimal (with smaller scale) can fit
+ parameters_[parameterIndex - 1] = decimalInput.setScale
(registerOutScale);
+ parameterMetaData_.sqlScale_[parameterIndex - 1] = registerOutScale;
+ }
+ catch (ArithmeticException e)
+ {
+ // if the new Decimal (with smaller scale) cannot fit into the DA
+ throw new SqlException (agent_.logWriter_, "The scale supplied by the
registerOutParameter method does " +
+ "not match with the setter method. Possible
loss of precision!");
+ }
+ }
+ }
+
+ public void close () throws SqlException
+ {
+ synchronized (connection_) {
+ if (agent_.loggingEnabled()) agent_.logWriter_.traceEntry (this,
"close");
+ closeX();
+ }
+ }
+
+ // An untraced version of close()
+ public void closeX () throws SqlException
+ {
+ if (!openOnClient_) return;
+ super.closeX();
+ if (parameterMetaData_ != null) {
+ parameterMetaData_.markClosed();
+ parameterMetaData_ = null;
+ }
+ sql_ = null;
+
+ // Apparently, the JVM is not smart enough to traverse parameters_[] and
null
+ // out its members when the entire array is set to null
(parameters_=null;).
+ if (parameters_ != null)
+ for (int i = 0; i < parameters_.length; i++) { parameters_[i] = null; }
+ parameters_ = null;
+
+ connection_.CommitAndRollbackListeners_.remove(this);
+ }
+
+}
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatement.java
------------------------------------------------------------------------------
svn:eol-style = native
Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatementCallbackInterface.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatementCallbackInterface.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatementCallbackInterface.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatementCallbackInterface.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,36 @@
+/*
+
+ Derby - Class org.apache.derby.client.am.PreparedStatementCallbackInterface
+
+ Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors,
where applicable.
+
+ Licensed 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.client.am;
+
+// Methods implemented by the common Prepared Statement class to handle
+// certain events that may originate from the material or common layers.
+//
+// Reply implementations may update prepared statement state via this
interface.
+//
+// The event interfaces are undergoing change, new events will be added soon
+// We want coarse grained event methods, rather than fine-grained events
+public interface PreparedStatementCallbackInterface extends
StatementCallbackInterface
+{
+
+ public void completeDescribeInput (ColumnMetaData parameterMetaData, Sqlca
sqlca);
+ public void completeDescribeOutput (ColumnMetaData resultSetMetaData, Sqlca
sqlca);
+
+}
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/PreparedStatementCallbackInterface.java
------------------------------------------------------------------------------
svn:eol-style = native
Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ProductLevel.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ProductLevel.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ProductLevel.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ProductLevel.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,95 @@
+/*
+
+ Derby - Class org.apache.derby.client.am.ProductLevel
+
+ Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors,
where applicable.
+
+ Licensed 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.client.am;
+
+public class ProductLevel
+{
+ public String databaseProductName_;
+ public int versionLevel_;
+ public int releaseLevel_;
+ public int modificationLevel_;
+
+ // The following value is sent in the srvrlslv level
+ public String databaseProductVersion_;
+
+ // The productID is set by the constructors.
+ // dabaseProductVersion added by derby to include srvrlslv
+ public ProductLevel (String productID, String databaseProductName,
+ String srvrlslv)
+ {
+ // this.productID has the following format
+ // CSS for Derby
+ // vv = version id
+ // rr = release id
+ // m = modification level
+ versionLevel_ = Integer.parseInt (productID.substring (3, 5));
+ releaseLevel_ = Integer.parseInt (productID.substring (5, 7));
+ modificationLevel_ = Integer.parseInt (productID.substring (7, 8));
+ databaseProductName_ = (databaseProductName == null) ?
+ "Derby" : databaseProductName; // This is the srvclsnm in
PROTOCOL.
+
+ // databaseProductVersion - extracted from the srvrlslv.
+ // srvrlslv has the format <PRDID>/<ALTERNATE VERSION FORMAT>
+ // for example Derby has a four part verison number so might send
+ // CSS10000/10.0.1.1 beta. If the alternate version format is not
+ // specified,
+ // databaseProductVersion_ will just be set to the srvrlslvl.
+ // final fallback will be the product id.
+ // this is the value returned with the getDatabaseProductVersion()
+ // metadata call
+ int dbVersionOffset = 0;
+ if (srvrlslv != null)
+ {
+ dbVersionOffset = srvrlslv.indexOf('/') + 1;
+ // if there was no '/' dbVersionOffset will just be 0
+ databaseProductVersion_ = srvrlslv.substring(dbVersionOffset);
+ }
+ if (databaseProductVersion_ == null)
+ databaseProductVersion_ = productID;
+ }
+
+ public boolean greaterThanOrEqualTo (int versionLevel, int releaseLevel, int
modificationLevel)
+ {
+ if (versionLevel_ > versionLevel)
+ return true;
+ else if (versionLevel_ == versionLevel) {
+ if (releaseLevel_ > releaseLevel)
+ return true;
+ else if (releaseLevel_ == releaseLevel)
+ if (modificationLevel_ >= modificationLevel)
+ return true;
+ }
+ return false;
+ }
+
+ public boolean lessThan (int versionLevel, int releaseLevel, int
modificationLevel)
+ {
+ if (versionLevel_ < versionLevel)
+ return true;
+ else if (versionLevel_ == versionLevel) {
+ if (releaseLevel_ < releaseLevel)
+ return true;
+ else if (releaseLevel_ == releaseLevel)
+ if (modificationLevel_ < modificationLevel)
+ return true;
+ }
+ return false;
+ }
+}
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ProductLevel.java
------------------------------------------------------------------------------
svn:eol-style = native
Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/QueryTimerTask.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/QueryTimerTask.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/QueryTimerTask.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/QueryTimerTask.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,55 @@
+/*
+
+ Derby - Class org.apache.derby.client.am.QueryTimerTask
+
+ Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors,
where applicable.
+
+ Licensed 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.client.am;
+
+public class QueryTimerTask extends java.util.TimerTask
+{
+ private Statement statement_;
+ private java.util.Timer timer_;
+
+ public QueryTimerTask (Statement statement, java.util.Timer timer)
+ {
+ statement_ = statement;
+ timer_ = timer;
+ }
+
+ public void run ()
+ {
+ timer_.cancel(); // method call on java.util.Timer to kill the timer
thread that triggered this task thread
+ try {
+ statement_.cancel(); // jdbc cancel
+ }
+ catch (SqlException e) {
+ SqlWarning warning = new SqlWarning (statement_.agent_.logWriter_,
+ "An exception occurred while trying to cancel a statement that has
timed out." +
+ " See chained SQLException.");
+ warning.setNextException (e);
+ statement_.accumulateWarning (warning);
+ }
+ boolean notYetRun = this.cancel(); // method call on java.util.TimerTask
to kill this task thread.
+ if (notYetRun) {
+ // The following is most likely just a bugcheck - but we'll see.
+ // May be able to remove it later.
+ SqlWarning warning = new SqlWarning (statement_.agent_.logWriter_,
+ "An unexpected error occurred while trying to cancel a statement that
has timed out.");
+ statement_.accumulateWarning (warning);
+ }
+ }
+}
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/QueryTimerTask.java
------------------------------------------------------------------------------
svn:eol-style = native
Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ResourceUtilities.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ResourceUtilities.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ResourceUtilities.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ResourceUtilities.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,63 @@
+/*
+
+ Derby - Class org.apache.derby.client.am.ResourceUtilities
+
+ Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors,
where applicable.
+
+ Licensed 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.client.am;
+
+import org.apache.derby.client.resources.ResourceKeys;
+
+public final class ResourceUtilities
+{
+ private final static Object[] emptyArgs__ = new Object[] {};
+
+ // Get resourced text and substitute arguments into text delimited with {i}
+ // using Java's builtin message formatter.
+ static public String getResource (String key, Object[] args)
+ {
+ try {
+ return java.text.MessageFormat.format
(Configuration.dncResources__.getString (key), args);
+ }
+ catch (java.util.MissingResourceException e) {
+ try {
+ return java.text.MessageFormat.format (
+ Configuration.dncResources__.getString
(ResourceKeys.missingResource__01),
+ new Object[] {e.getKey(), e.getClassName ()});
+ }
+ catch (java.util.MissingResourceException e2) {
+ return java.text.MessageFormat.format (
+ "No resource for key {0} could be found in resource bundle {1}.",
+ new Object[] {e.getKey(), e.getClassName ()});
+ }
+ }
+ }
+
+ static public String getResource (String key)
+ {
+ return getResource (key, emptyArgs__);
+ }
+
+ // This method is necessary for java.text.MessageFormat.format to work
+ // properly because arguments may not be null.
+ static String getMessage (java.lang.Exception e)
+ {
+ return (e.getMessage() == null) ? "" : e.getMessage();
+ }
+
+}
+
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/am/ResourceUtilities.java
------------------------------------------------------------------------------
svn:eol-style = native
