db-derby-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From banda...@apache.org
Subject svn commit: r165178 [21/26] - in /incubator/derby/code/trunk: ./ java/client/ java/client/org/ java/client/org/apache/ java/client/org/apache/derby/ java/client/org/apache/derby/client/ java/client/org/apache/derby/client/am/ java/client/org/apache/derby/client/net/ java/client/org/apache/derby/client/resources/ java/client/org/apache/derby/jdbc/ tools/ant/properties/
Date Thu, 28 Apr 2005 19:05:45 GMT
Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetStatementReply.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetStatementRequest.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetStatementRequest.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetStatementRequest.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetStatementRequest.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,1580 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.NetStatementRequest
+
+   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.net;
+
+import org.apache.derby.client.am.SqlException;
+import org.apache.derby.client.am.ColumnMetaData;
+import org.apache.derby.client.am.Types;
+import org.apache.derby.client.am.Blob;
+import org.apache.derby.client.am.Clob;
+import org.apache.derby.client.am.ResultSet;
+import org.apache.derby.client.am.Section;
+
+// For performance, should we worry about the ordering of our DDM command parameters
+public class NetStatementRequest extends NetPackageRequest implements StatementRequestInterface
+{
+  java.util.ArrayList extdtaPositions_ = null; // Integers: build EXTDTA for column i
+  int overrideLid_ = FdocaConstants.FIRST_OVERRIDE_LID;
+
+  // promototed parameters hold parameters that are promotoed to a different
+  // data type because they are too large to represent in PROTOCOL otherwise.
+  // This currently only applies for promotion of (VAR)CHAR -> CLOB and (VAR)BINARY -> BLOB
+  // The key for this structure is the parameter index.  Note that having this
+  // collection does not eliminate the need for extdtaPositions_ because that
+  // is still needed for non-promototed LOBs
+  java.util.HashMap promototedParameters_ = new java.util.HashMap ();
+  NetStatementRequest (NetAgent netAgent, CcsidManager ccsidManager, int bufferSize)
+  {
+    super (netAgent, ccsidManager, bufferSize);
+  }
+
+  //----------------------------- entry points ---------------------------------
+
+  // Write the message to perform an execute immediate.
+  // The SQL statement sent as command data cannot contain references
+  // to either input variables or output variables.
+  //
+  // preconditions:
+  public void writeExecuteImmediate (NetStatement materialStatement,
+                                     String sql,
+                                     Section section) throws SqlException
+  {
+    buildEXCSQLIMM (section,
+                    false,                    //sendQryinsid
+                    0);                        //qryinsid
+    buildSQLSTTcommandData (sql); // statement follows in sqlstt command data object
+  }
+
+  // Write the message to preform a prepare into.
+  // Once the SQL statement has been prepared, it is executed until the unit of work, in
+  // which the PRPSQLSTT command was issued, ends.  An exception to this is if
+  // Keep Dynamic is being used.
+  //
+  // preconditions:
+  public void writePrepareDescribeOutput (NetStatement materialStatement,
+                                          String sql,
+                                          Section section) throws SqlException
+  {
+    buildPRPSQLSTT (section,
+                    sql,
+                    true,   //sendRtnsqlda
+                    true,   //sendTypsqlda
+                    CodePoint.TYPSQLDA_X_OUTPUT);  //typsqlda
+
+    if (((NetStatement) materialStatement).statement_.cursorAttributesToSendOnPrepare_ != null)
+      buildSQLATTRcommandData (((NetStatement) materialStatement).statement_.cursorAttributesToSendOnPrepare_);
+
+    buildSQLSTTcommandData (sql);  // statement follows in sqlstt command data object
+  }
+
+  // Write the message to perform a reprepare.
+  //
+  // preconditions:
+  public void writePrepare (NetStatement materialStatement,
+                            String sql,
+                            Section section) throws SqlException
+  {
+    buildPRPSQLSTT (section,
+                    sql,
+                    false,  //sendRtnsqlda
+                    false,  //sendTypsqlda
+                    0);      //typsqlda
+
+    if (((NetStatement) materialStatement).statement_.cursorAttributesToSendOnPrepare_ != null)
+      buildSQLATTRcommandData (((NetStatement) materialStatement).statement_.cursorAttributesToSendOnPrepare_);
+
+    buildSQLSTTcommandData (sql); // statement follows in sqlstt command data object
+  }
+
+  // Write the message to execute  prepared sql statement.
+  //
+  // preconditions:
+  public void writeExecute (NetPreparedStatement materialPreparedStatement,
+                            Section section,
+                            ColumnMetaData parameterMetaData,
+                            Object[] inputs,
+                            int numInputColumns,
+                            boolean outputExpected,
+                            boolean chained
+                            ) throws SqlException  // chained flag for blobs only  //dupqry
+  {
+    buildEXCSQLSTT (section,
+                    true,             // sendOutexp
+                    outputExpected,   // outexp
+                    false,            // sendPrcnam
+                    null,             // prcnam
+                    false,            // sendQryblksz
+                    false,            // sendMaxrslcnt,
+                    0,                // maxrslcnt,
+                    false,            // sendMaxblkext
+                    0,                // maxblkext
+                    false,            // sendRslsetflg
+                    0,                // resultSetFlag
+                    false,            // sendQryrowset
+                    0);               // qryrowset
+
+    if (numInputColumns > 0) {
+      if ((extdtaPositions_ != null) && (!extdtaPositions_.isEmpty()))
+        extdtaPositions_.clear();  // reset extdta column position markers
+
+        boolean overrideExists = buildSQLDTAcommandData (numInputColumns,
+                                parameterMetaData,
+                                inputs);
+
+        // can we eleminate the chain argument needed for lobs
+        buildEXTDTA (parameterMetaData, inputs, chained);
+    }
+  }
+
+
+  // Write the message to open a bound or prepared query with input parameters.
+  // Check this -> For open query with input parameters
+  //
+  // preconditions:
+  public void writeOpenQuery (NetPreparedStatement materialPreparedStatement,
+                              Section section,
+                              int fetchSize,
+                              int resultSetType,
+                              int numInputColumns,
+                              org.apache.derby.client.am.ColumnMetaData parameterMetaData,
+                              Object[] inputs) throws SqlException
+  {
+    boolean sendQryrowset = checkSendQryrowset (fetchSize, resultSetType);
+    fetchSize = checkFetchsize (fetchSize, resultSetType);
+    // think about if there is a way we can call build ddm just passing ddm parameters and not passing the material ps object
+    // maybe not, if sometimes we need to set the caches hanging off the ps object during the ddm build
+    // maybe we can extricate conditionals in the build ddm logic outside
+
+    buildOPNQRY (section,
+                 sendQryrowset,
+                 fetchSize);
+
+
+    // may be able to merge this with firstContinueQuery_ and push above conditional to common
+    ((NetStatement) materialPreparedStatement).qryrowsetSentOnOpnqry_ = sendQryrowset;
+
+    if (numInputColumns > 0) {
+      if ((extdtaPositions_ != null)  && (!extdtaPositions_.isEmpty()))
+        extdtaPositions_.clear();  // reset extdta column position markers
+                                   // is this the best place for this
+                                   // EXCSQSTT needs this too
+
+      // think about having this method return a boolean to
+      // indicate the extdta should be built
+      boolean overrideExists = buildSQLDTAcommandData (numInputColumns,
+                              parameterMetaData,
+                              inputs);
+
+      // can we eleminate the chain argument needed for lobs
+      // do we chain after Extdta's on open, verify this
+      buildEXTDTA (parameterMetaData,
+                   inputs,
+                   false);  //chained, do we chain after Extdta's on open
+    }
+  }
+
+  // Write the message to open a bound or prepared query without input parameters.
+  // Check this-> For open query without input parameters
+  public void writeOpenQuery (NetStatement materialStatement,
+                              Section section,
+                              int fetchSize,
+                              int resultSetType) throws SqlException
+  {
+    boolean sendQryrowset = checkSendQryrowset (fetchSize, resultSetType);
+    fetchSize = checkFetchsize (fetchSize, resultSetType);
+
+    // think about if there is a way we can call build ddm just passing ddm parameters and not passing the material ps object
+    // maybe not, if sometimes we need to set the caches hanging off the ps object during the ddm build
+    // maybe we can extricate conditionals in the build ddm logic outside
+    buildOPNQRY (section,
+                 sendQryrowset,
+                 fetchSize);
+
+
+    // may be able to merge this with firstContinueQuery_ and push above conditional to common
+    ((NetStatement) materialStatement).qryrowsetSentOnOpnqry_ = sendQryrowset; // net-specific event
+
+
+  }
+
+  // Write the message to peform a describe input.
+  //
+
+  public void writeDescribeInput (NetPreparedStatement materialPreparedStatement,
+                                  Section section) throws SqlException
+  {
+    int typsqlda = CodePoint.TYPSQLDA_X_INPUT;
+
+    buildDSCSQLSTT (section,
+                    true,                        //sendTypsqlda
+                    typsqlda);
+  }
+
+  // Write the message to peform a describe output.
+  //
+  // preconditions:
+  public void writeDescribeOutput (NetPreparedStatement materialPreparedStatement,
+                                   Section section) throws SqlException
+  {
+    // pick standard, light, extended sqlda. possibly push this up even more
+    // right now use SQLAM level as determining factor and go for the most data.
+    // if standard is the only suported option, don't send the typsqlda
+    // and let server default to standard.  This prevents accidentally sending
+    // a typsqlda to a downlevel server.  typsqlda is only supported at sqlam 6.
+//KATHEY CHECK
+      buildDSCSQLSTT (section,
+                      true,  //sendTypsqlda
+                      CodePoint.TYPSQLDA_X_OUTPUT);  //typsqlda
+  }
+
+  // Write the message to execute a stored procedure.
+  //
+  // preconditions:
+  public void writeExecuteCall (NetStatement materialStatement,
+                                boolean outputExpected,
+                                String procedureName,
+                                Section section,
+                                int fetchSize,
+                                boolean suppressResultSets,  // for batch updates == true
+                                int resultSetType,
+                                ColumnMetaData parameterMetaData,
+                                Object[] inputs) throws SqlException // chain is for blobs
+  {
+    // always send QRYROWSET on EXCSQLSTT
+    boolean sendQryrowset = true;
+    fetchSize = (fetchSize == 0) ? org.apache.derby.client.am.Configuration.defaultFetchSize : fetchSize;
+
+    boolean sendPrcnam = (procedureName != null) ? true : false;
+    int numParameters = (parameterMetaData != null) ? parameterMetaData.columns_ : 0;
+    outputExpected = numParameters > 0;
+
+    // is it right here to send maxblkext (-1)
+    buildEXCSQLSTT (section,
+                    true,           // sendOutexp
+                    outputExpected, // outexp
+                    sendPrcnam,     // sendPrcnam
+                    procedureName,  // prcnam
+                    true,            // sendQryblksz
+                    !suppressResultSets,         // sendMaxrslcnt,
+                    CodePoint.MAXRSLCNT_NOLIMIT, // maxrslcnt,
+                    true,           // sendMaxblkext
+                    -1,             // maxblkext (-1 for AR capable of receiving entire result set)
+                    true,           // sendRslsetflg
+                    calculateResultSetFlags(), // resultSetFlag
+                    sendQryrowset,  // sendQryrowset
+                    fetchSize);      // qryrowset
+
+    if (numParameters > 0) {
+      if ((extdtaPositions_ != null)  && (!extdtaPositions_.isEmpty()))
+        extdtaPositions_.clear();  // reset extdta column position markers
+                                   // is this the best place for this (OPNQRY needs this too)
+
+        // think about having this method return a boolean to
+        // indicate the extdta should be built
+        boolean overrideExists = buildSQLDTAcommandData (numParameters,
+                                parameterMetaData,
+                                inputs);
+
+        buildEXTDTA (parameterMetaData, inputs, false); // no chained autocommit for CALLs
+    }
+
+    ((NetStatement) materialStatement).qryrowsetSentOnOpnqry_ = sendQryrowset;
+  }
+
+  // Write the message to execute an SQL Set Statement.
+/*
+  public void writeSetGenericSQLSetInfo (org.apache.derby.client.am.SetGenericSQLSetPiggybackCommand setGenericSQLSetPiggybackCommand,
+                                  org.apache.derby.client.am.JDBCSection section) throws SqlException
+  {
+    buildEXCSQLSET (section);
+
+    java.util.List sqlsttList = setGenericSQLSetPiggybackCommand.getList();
+    for (int i = 0; i < sqlsttList.size(); i++) {
+      String sql = (String)sqlsttList.get(i);
+      // Build SQLSTT only for the SET statement that coming from the server after RLSCONV
+      buildSQLSTTcommandData (sql);
+    }
+  }
+
+*/
+  //----------------------helper methods----------------------------------------
+  // These methods are "private protected", which is not a recognized java privilege,
+  // but means that these methods are private to this class and to subclasses,
+  // and should not be used as package-wide friendly methods.
+
+  // Build the Open Query Command to open a query to a relational database.
+  // At SQLAM >= 7 we can request the return of a DA, are there
+  // scenarios where this should currently be done (it is not supported now)
+  //
+  // preconditions:
+  //   the sqlam and/or prdid must support command and parameters passed to this method,
+  //   method will not validate against the connection's level of support
+  //
+  void buildOPNQRY (Section section,
+                    boolean sendQueryRowSet,
+                    int fetchSize
+                    ) throws SqlException
+  {
+    createCommand ();
+    markLengthBytes (CodePoint.OPNQRY);
+
+    buildPKGNAMCSN (section);
+    buildQRYBLKSZ();  // specify a hard coded query block size
+
+    if (sendQueryRowSet) {
+      buildMAXBLKEXT (-1);
+      buildQRYROWSET (fetchSize);
+    }
+
+    updateLengthBytes();  // opnqry is complete
+  }
+
+  // Build the Execute Immediate SQL Statement Command to
+  // execute a non-cursor SQL statement sent as command data.
+  //
+  // precondtions:
+  void buildEXCSQLIMM (Section section,
+                       boolean sendQryinsid,
+                       long qryinsid) throws SqlException
+  {
+    createCommand ();
+    markLengthBytes (CodePoint.EXCSQLIMM);
+
+    buildPKGNAMCSN (section);
+    buildRDBCMTOK();
+    if (sendQryinsid) buildQRYINSID (qryinsid);
+
+    updateLengthBytes();
+  }
+
+  // Build the Prepare SQL Statement Command to dynamically binds an
+  // SQL statement to a section in an existing relational database (RDB) package.
+  //
+  // preconditions:
+  //   the sqlam and/or prdid must support command and parameters passed to this method,
+  //   method will not validate against the connection's level of support
+  void buildPRPSQLSTT (Section section,
+                       String sql,
+                       boolean sendRtnsqlda,
+                       boolean sendTypsqlda,
+                       int typsqlda
+                       ) throws SqlException
+  {
+    createCommand ();
+    markLengthBytes (CodePoint.PRPSQLSTT);
+
+    buildPKGNAMCSN (section);
+    if (sendRtnsqlda) buildRTNSQLDA();
+    if (sendTypsqlda) buildTYPSQLDA (typsqlda);
+
+    updateLengthBytes();
+  }
+
+  // Build the command to execute an SQL SET Statement.
+  // Called by NETSetClientPiggybackCommand.write()
+  //
+  // preconditions:
+  //   the sqlam and/or prdid must support command and parameters passed to this method,
+  //   method will not validate against the connection's level of support
+  void buildEXCSQLSET (Section section)
+                        throws SqlException
+  {
+    createCommand ();
+    markLengthBytes (CodePoint.EXCSQLSET);
+    buildPKGNAMCSN (section);  // is this PKGNAMCSN or PKGNAMCT
+    updateLengthBytes();
+  }
+
+  // Build the Execute SQL Statement (EXCSQLSTT) Command
+  // to execute a non-cursor SQL statement previously bound into a named package
+  // of a relational database (RDB).  The SQL statement can optionally include
+  // references to input variables, output variables, or both.
+  //
+  // At SQLAM >= 7 we can get a DA back on this, are there times that we want to request it
+  // If so, we probably want to pass a parameter indicating the sqldaLevel requested.
+  //
+  // preconditions:
+  //   the sqlam and/or prdid must support command and parameters passed to this method,
+  //   method will not validate against the connection's level of support
+  // Here is the preferred codepoint ordering:
+  // PKGNAMCSN
+  // RDBCMTOK
+  // OUTEXP
+  // QRYBLKSZ
+  // MAXBLKEXT
+  // MAXRSLCNT
+  // RSLSETFLG
+  // QRYROWSET
+  // RTNSQLDA
+  // TYPSQLDA
+  // NBRROW
+  // ATMIND
+  // PRCNAM
+  // OUTOVROPT
+  // RDBNAM
+  void buildEXCSQLSTT (Section section,
+                       boolean sendOutexp,
+                       boolean outexp,
+                       boolean sendPrcnam,
+                       String prcnam,
+                       boolean sendQryblksz,
+                       boolean sendMaxrslcnt,
+                       int maxrslcnt,
+                       boolean sendMaxblkext,
+                       int maxblkext,
+                       boolean sendRslsetflg,
+                       int resultSetFlag,
+                       boolean sendQryrowset,
+                       int qryrowset
+                       ) throws SqlException
+  {
+    createCommand ();
+    markLengthBytes (CodePoint.EXCSQLSTT);
+
+    buildPKGNAMCSN (section);
+    buildRDBCMTOK();
+    if (sendOutexp) buildOUTEXP (outexp);
+    if (sendQryblksz) buildQRYBLKSZ();
+    if (sendQryrowset && sendMaxblkext) buildMAXBLKEXT (maxblkext);
+    if (sendMaxrslcnt) buildMAXRSLCNT (maxrslcnt);
+    if (sendRslsetflg) buildRSLSETFLG (resultSetFlag);
+    if (sendQryrowset) buildQRYROWSET (qryrowset);
+    if (sendPrcnam) buildPRCNAM (prcnam);
+
+    updateLengthBytes();  // command is complete, update the length bytes
+  }
+
+  // Build the Describe SQL Statement command.
+  //
+  // preconditions:
+  //   the sqlam and/or prdid must support command and parameters passed to this method,
+  //   method will not validate against the connection's level of support
+  void buildDSCSQLSTT (Section section,
+                       boolean sendTypsqlda,
+                       int typsqlda
+                       ) throws SqlException
+  {
+    createCommand ();
+    markLengthBytes (CodePoint.DSCSQLSTT);
+
+    buildPKGNAMCSN (section);
+    if (sendTypsqlda) buildTYPSQLDA (typsqlda);
+
+    updateLengthBytes();
+  }
+
+  // Build the SQL Program Variable Data Command Data Object.
+  // This object contains the input data to an SQL statement
+  // that an RDB is executing.
+  //
+  // preconditions:
+  boolean buildSQLDTAcommandData (int numInputColumns,
+                               ColumnMetaData parameterMetaData,
+                               Object[] inputRow) throws SqlException
+  {
+    createEncryptedCommandData();
+
+    int loc = offset_;
+
+    markLengthBytes (CodePoint.SQLDTA);
+
+    int[][] protocolTypesAndLengths = allocateLidAndLengthsArray (parameterMetaData);
+
+    java.util.Hashtable protocolTypeToOverrideLidMapping = null;
+    java.util.ArrayList mddOverrideArray = null;
+    protocolTypeToOverrideLidMapping =
+      computeProtocolTypesAndLengths (inputRow, parameterMetaData, protocolTypesAndLengths,
+                                   protocolTypeToOverrideLidMapping) ;
+
+    boolean overrideExists = false;
+
+    buildFDODSC (numInputColumns,
+                 protocolTypesAndLengths,
+                 overrideExists,
+                 protocolTypeToOverrideLidMapping,
+                 mddOverrideArray);
+
+    buildFDODTA (numInputColumns,
+                 protocolTypesAndLengths,
+                 inputRow);
+
+    updateLengthBytes(); // for sqldta
+    if (netAgent_.netConnection_.getSecurityMechanism() ==
+        NetConfiguration.SECMEC_EUSRIDDTA ||
+        netAgent_.netConnection_.getSecurityMechanism() ==
+        NetConfiguration.SECMEC_EUSRPWDDTA)
+      encryptDataStream(loc);
+
+    return overrideExists;
+  }
+
+  // Build the FDOCA Data Descriptor Scalar whose value is a FDOCA
+  // Descriptor or a segment of an FDOCA Descriptor.
+  //
+  // preconditions:
+  private void buildFDODSC (int numColumns,
+                            int[][] protocolTypesAndLengths,
+                            boolean overrideExists,
+                            java.util.Hashtable overrideMap,
+                            java.util.ArrayList overrideArray) throws SqlException
+  {
+    markLengthBytes (CodePoint.FDODSC);
+    buildSQLDTA (numColumns, protocolTypesAndLengths, overrideExists, overrideMap, overrideArray);
+    updateLengthBytes();
+  }
+
+  // Build the FDOCA SQLDTA Late Row Descriptor.
+  //
+  // preconditions:
+  protected void buildSQLDTA (int numColumns,
+                              int[][] lidAndLengthOverrides,
+                              boolean overrideExists,
+                              java.util.Hashtable overrideMap,
+                              java.util.ArrayList overrideArray) throws SqlException
+  {
+    // mdd overrides need to be built first if any before the descriptors are built.
+    if (overrideExists) {
+      buildMddOverrides (overrideArray);
+      writeBytes (FdocaConstants.MDD_SQLDTAGRP_TOSEND);
+    }
+
+    buildSQLDTAGRP (numColumns, lidAndLengthOverrides, overrideExists, overrideMap);
+
+    if (overrideExists) writeBytes (FdocaConstants.MDD_SQLDTA_TOSEND);
+    writeBytes (FdocaConstants.SQLDTA_RLO_TOSEND);
+  }
+
+  // Build the FDOCA SQLDTAGRP Late Group Descriptor.
+  // preconditions:
+  protected void buildSQLDTAGRP (int numVars,
+                                 int[][] lidAndLengthOverrides,
+                                 boolean mddRequired,
+                                 java.util.Hashtable overrideMap) throws SqlException
+  {
+    int n = 0;
+    int offset = 0;
+
+    n = calculateColumnsInSQLDTAGRPtriplet (numVars);
+    buildTripletHeader (((3 * n) + 3),
+                        FdocaConstants.NGDA_TRIPLET_TYPE,
+                        FdocaConstants.SQLDTAGRP_LID);
+
+    do {
+      writeLidAndLengths (lidAndLengthOverrides, n, offset, mddRequired, overrideMap);
+      numVars -= n;
+      if (numVars == 0) break;
+
+      offset += n;
+        n = calculateColumnsInSQLDTAGRPtriplet (numVars);
+        buildTripletHeader (((3 * n) + 3),
+                            FdocaConstants.CPT_TRIPLET_TYPE,
+                            0x00);
+    } while (true);
+      }
+
+/////////// perf end
+
+
+  protected void buildOUTOVR (ResultSet resultSet,
+                              ColumnMetaData resultSetMetaData) throws SqlException
+  {
+    createCommandData();
+    markLengthBytes (CodePoint.OUTOVR);
+    int[][] outputOverrides =
+      calculateOUTOVRLidAndLengthOverrides (resultSet, resultSetMetaData);
+    buildSQLDTARD (resultSetMetaData.columns_, outputOverrides);
+    updateLengthBytes();
+  }
+
+  private int[][] calculateOUTOVRLidAndLengthOverrides (ResultSet resultSet,
+                                                        ColumnMetaData resultSetMetaData)
+  {
+    int numVars = resultSetMetaData.columns_;
+    int[][] lidAndLengths = new int[numVars][2]; //everything initialized to "default triplet"
+
+    return lidAndLengths;
+  }
+
+  protected void buildSQLDTARD (int numColumns, int[][] lidAndLengthOverrides) throws SqlException
+  {
+    buildSQLCADTA (numColumns, lidAndLengthOverrides);
+    writeBytes (FdocaConstants.SQLDTARD_RLO_TOSEND);
+  }
+
+  protected void buildSQLCADTA (int numColumns, int[][] lidAndLengthOverrides) throws SqlException
+  {
+    buildSQLDTAGRP (numColumns, lidAndLengthOverrides, false, null);  // false means no mdd override
+    writeBytes (FdocaConstants.SQLCADTA_RLO_TOSEND);
+  }
+
+  private void buildFDODTA (int numVars,
+                            int[][] protocolTypesAndLengths,
+                            Object[] inputs
+                            ) throws SqlException
+  {
+    long dataLength = 0;
+    Object o = null;
+
+    markLengthBytes (CodePoint.FDODTA);
+    write1Byte (FdocaConstants.NULL_LID); // write the 1-byte row indicator
+
+    // write data for each input column
+    for (int i = 0; i < numVars; i++) {
+      if (inputs[i] == null) {
+        if ((protocolTypesAndLengths[i][0] % 2) == 1)
+          write1Byte (FdocaConstants.NULL_DATA);
+        else {
+          //bug check
+        }
+      }
+      else {
+        if ((protocolTypesAndLengths[i][0] % 2) == 1)
+          write1Byte (FdocaConstants.INDICATOR_NULLABLE);
+
+        switch (protocolTypesAndLengths[i][0] | 0x01) {  // mask out null indicator
+        case FdocaConstants.PROTOCOL_TYPE_NVARMIX:
+        case FdocaConstants.PROTOCOL_TYPE_NLONGMIX:
+          // What to do for server that don't understand 1208 (UTF-8)
+          // check for a promototed type, and use that instead if it exists
+          o = retrievePromotedParameterIfExists (i);
+          if ( o == null ) {
+          writeSingleorMixedCcsidLDString ((String) inputs[i], netAgent_.typdef_.getCcsidMbcEncoding());
+          }
+          else { // use the promototed object instead
+            Clob c = (Clob)o;
+            dataLength = c.length();
+            setFDODTALobLength (protocolTypesAndLengths, i, dataLength);
+          }
+          break;
+
+        case FdocaConstants.PROTOCOL_TYPE_NVARCHAR:
+        case FdocaConstants.PROTOCOL_TYPE_NLONG:
+          o = retrievePromotedParameterIfExists (i);
+          if ( o == null ) {
+
+          }
+          else { // use the promototed object instead
+            dataLength = ((Clob)o).length();
+            setFDODTALobLength (protocolTypesAndLengths, i, dataLength);
+          }
+          break;
+
+        case FdocaConstants.PROTOCOL_TYPE_NINTEGER:
+          writeIntFdocaData (((Integer) inputs[i]).intValue());
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NSMALL:
+          writeShortFdocaData (((Short) inputs[i]).shortValue());
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NFLOAT4:
+          writeFloat (((Float) inputs[i]).floatValue());
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NFLOAT8:
+          writeDouble (((Double) inputs[i]).doubleValue());
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NDECIMAL:
+          writeBigDecimal ((java.math.BigDecimal) inputs[i],
+                           (protocolTypesAndLengths[i][1] >> 8) & 0xff, // described precision not actual
+                           protocolTypesAndLengths[i][1] & 0xff); // described scale, not actual
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NDATE:
+            writeDate ((java.sql.Date) inputs[i]);
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NTIME:
+          writeTime ((java.sql.Time) inputs[i]);
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NTIMESTAMP:
+          writeTimestamp ((java.sql.Timestamp) inputs[i]);
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NINTEGER8:
+          writeLongFdocaData (((Long) inputs[i]).longValue());
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NVARBYTE:
+        case FdocaConstants.PROTOCOL_TYPE_NLONGVARBYTE:
+          o = retrievePromotedParameterIfExists (i);
+          if (o == null) {
+            writeLDBytes ((byte[]) inputs[i]);
+          }
+          else { // use the promototed object instead
+            Blob b = (Blob) o;
+            dataLength = b.length();
+            setFDODTALobLength (protocolTypesAndLengths, i, dataLength);
+          }
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NLOBCSBCS:
+        case FdocaConstants.PROTOCOL_TYPE_NLOBCDBCS:
+          // check for a promoted Clob
+          o = retrievePromotedParameterIfExists(i);
+          if (o == null) {
+            try {
+              dataLength = ((java.sql.Clob) inputs[i]).length();
+            }
+            catch (java.sql.SQLException e) {
+              if ( ! (e instanceof org.apache.derby.client.am.SqlException)) {
+                SqlException toThrow = new SqlException (
+                  netAgent_.logWriter_,
+                  "Error obtaining length of external clob object, exception follows. ");
+                toThrow.setNextException (e);
+                throw toThrow;
+              }
+              else
+              throw new SqlException(netAgent_.logWriter_, e, "Error obtaining length of blob object, exception follows. ");
+            }
+          }
+          else {
+            dataLength = ((Clob) o).length();
+          }
+          setFDODTALobLength (protocolTypesAndLengths, i, dataLength);
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NLOBBYTES:
+          // check for a promoted Clob
+          o = retrievePromotedParameterIfExists(i);
+          if (o == null) {
+            try {
+              dataLength = ((java.sql.Blob) inputs[i]).length();
+            }
+            catch (java.sql.SQLException e) {
+              if ( ! (e instanceof org.apache.derby.client.am.SqlException)) {
+                SqlException toThrow = new SqlException (
+                  netAgent_.logWriter_,
+                  "Error obtaining length of external blob object, exception follows. ");
+                toThrow.setNextException (e);
+                throw toThrow;
+              }
+              else
+                throw new SqlException(netAgent_.logWriter_, e, "Error obtaining length of blob object, exception follows. ");
+            }
+          }
+          else { // use promoted Blob
+            dataLength = ((Blob) o).length();
+          }
+          setFDODTALobLength (protocolTypesAndLengths, i, dataLength);
+          break;
+        case FdocaConstants.PROTOCOL_TYPE_NLOBCMIXED :
+          // check for a promoted Clob
+          o = retrievePromotedParameterIfExists(i);
+          if (o == null) {
+            if (((Clob) inputs[i]).isString())
+              dataLength = ((Clob) inputs[i]).getUTF8Length();
+            else // must be a Unicode stream
+              dataLength = ((Clob) inputs[i]).length();
+          }
+          else { // use promoted Clob
+            dataLength = ((Clob) o).length();
+          }
+          setFDODTALobLength(protocolTypesAndLengths, i, dataLength);
+          break;
+        default:
+          throw new SqlException (netAgent_.logWriter_, "unrecognized jdbc type. " +
+                                  " type: " + protocolTypesAndLengths[i][0] +
+                                  ", columnCount: " + numVars +
+                                  ", columnIndex: " + i);
+        }
+      }
+    }
+    updateLengthBytes(); // for fdodta
+  }
+
+  // preconditions:
+  private void buildEXTDTA(ColumnMetaData parameterMetaData,
+                           Object[] inputRow,
+                           boolean chained
+                    ) throws SqlException
+  {
+    // build the EXTDTA data, if necessary
+    if (extdtaPositions_ != null) {
+      boolean chainFlag, chainedWithSameCorrelator;
+
+      for (int i = 0; i < extdtaPositions_.size(); i++) {
+        int index = ((Integer) extdtaPositions_.get(i)).intValue();
+
+        // is this the last EXTDTA to be built?
+        if (i != extdtaPositions_.size() - 1) { // no
+          chainFlag = true;
+          chainedWithSameCorrelator = true;
+        }
+        else { // yes
+          chainFlag = chained;
+          chainedWithSameCorrelator = false;
+        }
+
+        // do we have to write a null byte?
+        boolean writeNullByte = false;
+		if (parameterMetaData.nullable_[index])
+            writeNullByte = true;
+		// Use the type of the input parameter rather than the input
+		// column if possible.
+		int parameterType = parameterMetaData.clientParamtertype_[index];
+		if (parameterType == 0)
+			parameterType = parameterMetaData.types_[index];
+
+        // the follow types are possible due to promotion to BLOB
+        if (parameterType == Types.BLOB
+          || parameterType == Types.BINARY
+          || parameterType == Types.VARBINARY
+          || parameterType == Types.LONGVARBINARY) {
+          Blob o = (Blob) retrievePromotedParameterIfExists(index);
+          java.sql.Blob b = (o == null) ? (java.sql.Blob) inputRow[index] : o;
+          boolean isExternalBlob = !(b instanceof org.apache.derby.client.am.Blob);
+          if (isExternalBlob) {
+            try {
+              writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+                CodePoint.EXTDTA,
+                (int) b.length(),
+                b.getBinaryStream(),
+                writeNullByte,
+                index + 1);
+            }
+            catch (java.sql.SQLException e) {
+              if (!(e instanceof org.apache.derby.client.am.SqlException)) {
+                SqlException toThrow = new SqlException(netAgent_.logWriter_, "Error occurred while streaming from external blob object, exception follows. ");
+                toThrow.setNextException(e);
+                throw toThrow;
+              }
+              else
+                throw new SqlException( netAgent_.logWriter_, e, "Error obtaining length of blob object, exception follows. ");
+            }
+          }
+          else if (((Blob) b).isBinaryStream()) {
+              writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+              CodePoint.EXTDTA,
+              (int) ((Blob) b).length(),
+              ((Blob) b).getBinaryStream(),
+              writeNullByte,
+              index + 1);
+          }
+          else { // must be a binary string
+            // note: a possible optimization is to use writeScalarLobBytes
+            //       when the input is small
+            //   use this: if (b.length () < DssConstants.MAX_DSS_LEN - 6 - 4)
+            //               writeScalarLobBytes (...)
+            // Yes, this would avoid having to new up a java.io.ByteArrayInputStream
+            writeScalarStream (chainFlag,
+              chainedWithSameCorrelator,
+              CodePoint.EXTDTA,
+              (int) ((Blob) b).length(),
+              ((Blob) b).getBinaryStream(),
+              writeNullByte,
+              index + 1);
+          }
+        }
+        // the follow types are possible due to promotion to CLOB
+        else if (
+          parameterType == Types.CLOB
+            || parameterType == Types.CHAR
+            || parameterType == Types.VARCHAR
+            || parameterType == Types.LONGVARCHAR) {
+          Clob o = (Clob) retrievePromotedParameterIfExists(index);
+          java.sql.Clob c = (o == null) ? (java.sql.Clob) inputRow[index] : o;
+          boolean isExternalClob = !(c instanceof org.apache.derby.client.am.Clob);
+
+          if (isExternalClob) {
+            try {
+              writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+                               CodePoint.EXTDTA,
+                               (int) c.length (),
+                               c.getCharacterStream(),
+                               writeNullByte,
+                               index + 1);
+              }
+              catch (java.sql.SQLException e) {
+                if (!(e instanceof org.apache.derby.client.am.SqlException)) {
+                  SqlException toThrow = new SqlException(netAgent_.logWriter_, "Error occurred while streaming from external clob object, exception follows. ");
+                  toThrow.setNextException(e);
+                  throw toThrow;
+                }
+                else
+                  throw new SqlException(netAgent_.logWriter_, e, "Error obtaining length of blob object, exception follows. ");
+              }
+            }
+            else if (((Clob) c).isCharacterStream()) {
+              writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+                               CodePoint.EXTDTA,
+                               (int) ((Clob) c).length (),
+                               ((Clob) c).getCharacterStream(),
+                               writeNullByte,
+                               index + 1);
+          }
+          else if (((Clob) c).isAsciiStream ())
+            writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+                               CodePoint.EXTDTA,
+                               (int) ((Clob) c).length (),
+                               ((Clob) c).getAsciiStream (),
+                               writeNullByte,
+                               index + 1);
+          else if (((Clob) c).isUnicodeStream ())
+            writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+                               CodePoint.EXTDTA,
+                               (int) ((Clob) c).length (),
+                               ((Clob) c).getUnicodeStream (),
+                               writeNullByte,
+                               index + 1);
+          else { // must be a String
+            // note: a possible optimization is to use writeScalarLobBytes
+            //       when the input is small.
+            //   use this: if (c.length () < DssConstants.MAX_DSS_LEN - 6 - 4)
+            //               writeScalarLobBytes (...)
+            writeScalarStream (chainFlag,
+                               chainedWithSameCorrelator,
+                               CodePoint.EXTDTA,
+                               (int) ((Clob) c).getUTF8Length (),
+                               new java.io.ByteArrayInputStream (((Clob) c).getUtf8String ()),
+                writeNullByte,
+                index + 1);
+            }
+        }
+      }
+    }
+  }
+
+
+  //-------------------------helper methods-------------------------------------
+  // returns the a promototedParameter object for index or null if it does not exist
+  private Object retrievePromotedParameterIfExists (int index) {
+
+   // consider using a nonsynchronized container or array
+    if (promototedParameters_.isEmpty()) return null;
+    return promototedParameters_.get(new Integer(index));
+  }
+
+  private int calculateColumnsInSQLDTAGRPtriplet (int numVars) {
+    if (numVars > FdocaConstants.MAX_VARS_IN_NGDA) //rename to MAX_VARS_IN_SQLDTAGRP_TRIPLET
+      return FdocaConstants.MAX_VARS_IN_NGDA;
+    return numVars;
+  }
+
+
+  // Consider refacctor so that this does not even have to look
+  // at the actual object data, and only uses tags from the meta data
+  // only have to call this once, rather than calling this for every input row
+  // backburner: after refactoring this, later on, think about replacing case statements with table lookups
+  private java.util.Hashtable computeProtocolTypesAndLengths (Object[] inputRow,
+                                                          ColumnMetaData parameterMetaData,
+                                                          int[][] lidAndLengths,
+                                                          java.util.Hashtable overrideMap
+                                                          ) throws SqlException
+  {
+    int numVars = parameterMetaData.columns_;
+    String s = null;
+    if (!promototedParameters_.isEmpty()) promototedParameters_.clear();
+
+    for (int i = 0; i < numVars; i++) {
+
+      int jdbcType;
+	  // Send the input type unless it is not available.
+	  // (e.g an output parameter)
+	  jdbcType = parameterMetaData.clientParamtertype_[i];
+	  if (jdbcType == 0)
+		  jdbcType = parameterMetaData.types_[i];
+
+      // jdbc semantics - This should happen outside of the build methods
+      // if describe input is not supported, we require the user to at least
+      // call setNull() and provide the type information.  Otherwise, we won't
+      // be able to guess the right PROTOCOL type to send to the server, and an
+      // exception is thrown.
+
+      if (jdbcType == 0)
+        throw new SqlException (netAgent_.logWriter_, "Invalid JDBC Type for parameter " + i);
+
+      switch (jdbcType) {
+        case java.sql.Types.CHAR :
+        case java.sql.Types.VARCHAR :
+          // lid: PROTOCOL_TYPE_NVARMIX, length override: 32767 (max)
+          // dataFormat: String
+          // this won't work if 1208 is not supported
+          s = (String) inputRow[i];
+          // assumes UTF-8 characters at most 3 bytes long
+          // Flow the String as a VARCHAR
+          if (s == null || s.length() <= 32767 / 3) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NVARMIX;
+            lidAndLengths[i][1] = 32767;
+          }
+          else {
+            // Flow the data as CLOB data if the data too large to for LONGVARCHAR
+            java.io.ByteArrayInputStream bais = null;
+            byte[] ba = null;
+            try {
+              ba = s.getBytes("UTF-8");
+              bais = new java.io.ByteArrayInputStream(ba);
+              Clob c = new Clob(netAgent_, bais, "UTF-8", ba.length);
+              // inputRow[i] = c;
+              // Place the new Lob in the promototedParameter_ collection for
+              // NetStatementRequest use
+              promototedParameters_.put(new Integer(i), c);
+
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCMIXED;
+              lidAndLengths[i][1] = buildPlaceholderLength(c.length());
+            }
+            catch (java.io.UnsupportedEncodingException e) {
+              throw new SqlException(netAgent_.logWriter_, e, "Error in building String parameter: throwable attached");
+            }
+          }
+          break;
+        case java.sql.Types.INTEGER :
+          // lid: PROTOCOL_TYPE_NINTEGER, length override: 4
+          // dataFormat: Integer
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NINTEGER;
+          lidAndLengths[i][1] = 4;
+          break;
+        case java.sql.Types.SMALLINT :
+		case java.sql.Types.TINYINT:
+		case java.sql.Types.BOOLEAN:
+		case java.sql.Types.BIT:
+          // lid: PROTOCOL_TYPE_NSMALL,  length override: 2
+          // dataFormat: Short
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NSMALL;
+          lidAndLengths[i][1] = 2;
+          break;
+        case java.sql.Types.REAL :
+          // lid: PROTOCOL_TYPE_NFLOAT4, length override: 4
+          // dataFormat: Float
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NFLOAT4;
+          lidAndLengths[i][1] = 4;
+          break;
+        case java.sql.Types.DOUBLE :
+        case java.sql.Types.FLOAT :
+          // lid: PROTOCOL_TYPE_NFLOAT8, length override: 8
+          // dataFormat: Double
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NFLOAT8;
+          lidAndLengths[i][1] = 8;
+          break;
+        case java.sql.Types.NUMERIC :
+        case java.sql.Types.DECIMAL :
+          // lid: PROTOCOL_TYPE_NDECIMAL
+          // dataFormat: java.math.BigDecimal
+          // input only:
+          //   if null and describe input - use describe input precision and scale
+          //   if not null and describe input - calculate precision and actual scale from data
+          //   if null and no describe input - guess with precision 1 scale 0
+          //   if not null and no describe input - calculate precision and actual scale from data
+          // output only:
+          //   use largest precision/scale based on registered scale from registerOutParameter
+          // inout:
+          //   if null - use largest precision/scale based on scale from registerOutParameter
+          //   if not null - write bigDecimal () pass registered scale so it can pad, you don't even
+          //      have to look at the actual scale at this level.
+          /*
+          if (parameterMetaData.isGuessed) {
+            java.math.BigDecimal bigDecimal = (java.math.BigDecimal) inputRow[i];
+            int precision = Utils.computeBigDecimalPrecision (bigDecimal);
+            lidAndLengths[i][1] = (precision << 8) + // use precision above
+                                (bigDecimal.scale() << 0);
+          }
+          */
+          // Split this entire method into two parts, the first method is called only once and the inputRow is not passed,!!
+          // the second method is called for every inputRow and overrides inputDA lengths/scales based upon the acutal data!
+          // for decimal and blob columns only
+          int precision = parameterMetaData.sqlPrecision_[i];
+          int scale = parameterMetaData.sqlScale_[i];
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NDECIMAL;
+          lidAndLengths[i][1] = (precision << 8) + (scale << 0);
+          break;
+        case java.sql.Types.DATE :
+          // for input, output, and inout parameters
+          // lid: PROTOCOL_TYPE_NDATE, length override: 8
+          // dataFormat: java.sql.Date
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NDATE;
+          lidAndLengths[i][1] = 10;
+          break;
+        case java.sql.Types.TIME :
+          // for input, output, and inout parameters
+          // lid: PROTOCOL_TYPE_NTIME, length override: 8
+          // dataFormat: java.sql.Time
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NTIME;
+          lidAndLengths[i][1] = 8;
+          break;
+        case java.sql.Types.TIMESTAMP :
+          // for input, output, and inout parameters
+          // lid: PROTOCOL_TYPE_NTIME, length overrid: 26
+          // dataFormat: java.sql.Timestamp
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NTIMESTAMP;
+          lidAndLengths[i][1] = 26;
+          break;
+        case java.sql.Types.BIGINT :
+          // if SQLAM < 6 this should be mapped to decimal (19,0) in common layer
+          // if SQLAM >=6, lid: PROTOCOL_TYPE_NINTEGER8, length override: 8
+          // dataFormat: Long
+          lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NINTEGER8;
+          lidAndLengths[i][1] = 8;
+          break;
+        case java.sql.Types.LONGVARCHAR :
+          // Is this the right thing to do  // should this be 32700
+          s = (String) inputRow[i];
+          if (s == null || s.length() <= 32767 / 3) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLONGMIX;
+            lidAndLengths[i][1] = 32767;
+          }
+          else {
+            // Flow the data as CLOB data if the data too large to for LONGVARCHAR
+            java.io.ByteArrayInputStream bais = null;
+            byte[] ba = null;
+            try {
+              ba = s.getBytes("UTF-8");
+              bais = new java.io.ByteArrayInputStream(ba);
+              Clob c = new Clob(netAgent_, bais, "UTF-8", ba.length);
+
+              // inputRow[i] = c;
+              // Place the new Lob in the promototedParameter_ collection for
+              // NetStatementRequest use
+              promototedParameters_.put(new Integer(i), c);
+
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCMIXED;
+              lidAndLengths[i][1] = buildPlaceholderLength(c.length());
+            }
+            catch (java.io.UnsupportedEncodingException e) {
+              throw new SqlException (netAgent_.logWriter_, e, "Error in building String parameter: throwable attached");
+            }
+          }
+          break;
+        case java.sql.Types.BINARY :
+        case java.sql.Types.VARBINARY :
+          byte[] ba = (byte[]) inputRow[i];
+          if (ba == null) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NVARBYTE;
+            lidAndLengths[i][1] = 32767;
+          }
+          else if (ba.length <= 32767) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NVARBYTE;
+            lidAndLengths[i][1] = 32767;
+          }
+          else {
+            // Promote to a BLOB. Only reach this path in the absence of describe information.
+            Blob b = new Blob(ba, netAgent_, 0);
+
+            // inputRow[i] = b;
+            // Place the new Lob in the promototedParameter_ collection for
+            // NetStatementRequest use
+            promototedParameters_.put(new Integer(i), b);
+
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBBYTES;
+            lidAndLengths[i][1] = buildPlaceholderLength(ba.length);
+          }
+          break;
+        case java.sql.Types.LONGVARBINARY :
+          ba = (byte[]) inputRow[i];
+          if (ba == null) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLONGVARBYTE;
+            lidAndLengths[i][1] = 32767;
+          }
+          else if (ba.length <= 32767) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLONGVARBYTE;
+            lidAndLengths[i][1] = 32767;
+          }
+          else {
+            // Promote to a BLOB. Only reach this path in the absensce of describe information.
+            Blob b = new Blob(ba, netAgent_, 0);
+
+            // inputRow[i] = b;
+            // Place the new Lob in the promototedParameter_ collection for
+            // NetStatementRequest use
+            promototedParameters_.put(new Integer(i), b);
+
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBBYTES;
+            lidAndLengths[i][1] = buildPlaceholderLength(ba.length);
+          }
+          break;
+        case java.sql.Types.BLOB :
+          java.sql.Blob b = (java.sql.Blob) inputRow[i];
+          if (b == null) {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBBYTES;
+            lidAndLengths[i][1] =
+              buildPlaceholderLength(parameterMetaData.sqlLength_[i]);
+          }
+          else {
+            lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBBYTES;
+            try {
+              lidAndLengths[i][1] = buildPlaceholderLength(b.length());
+            }
+            catch (java.sql.SQLException e) {
+              if (!(e instanceof org.apache.derby.client.am.SqlException)) {
+                SqlException toThrow =
+                  new SqlException(netAgent_.logWriter_, "Error obtaining length of external blob object, exception follows. ");
+                toThrow.setNextException(e);
+                throw toThrow;
+              }
+              else
+                throw new SqlException(netAgent_.logWriter_, e, "Error obtaining length of blob object, exception follows. ");
+            }
+          }
+          break;
+        case java.sql.Types.CLOB :
+          {
+            // use columnMeta.singleMixedByteOrDouble_ to decide protocolType
+            java.sql.Clob c = (java.sql.Clob) inputRow[i];
+            boolean isExternalClob = !(c instanceof org.apache.derby.client.am.Clob);
+            long lobLength = 0;
+            if (c == null) {
+              lobLength = parameterMetaData.sqlLength_[i];
+            }
+            else if (isExternalClob) {
+              try {
+                lobLength = c.length();
+              }
+              catch (java.sql.SQLException e) {
+                if (!(e instanceof org.apache.derby.client.am.SqlException)) {
+                  SqlException toThrow =
+                    new SqlException(netAgent_.logWriter_, "Error obtaining length of external clob object, exception follows. ");
+                  toThrow.setNextException(e);
+                  throw toThrow;
+                }
+                else
+                  throw new SqlException(netAgent_.logWriter_, e, "Error obtaining length of clob object, exception follows. ");
+              }
+            }
+            else {
+              lobLength = ((Clob) c).length();
+            }
+            if (c == null) {
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCMIXED;
+              lidAndLengths[i][1] = buildPlaceholderLength(lobLength);
+            }
+            else if (isExternalClob) {
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCDBCS;
+              lidAndLengths[i][1] = buildPlaceholderLength(lobLength);
+            }
+            else if (((Clob) c).isCharacterStream()) {
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCDBCS;
+              lidAndLengths[i][1] = buildPlaceholderLength(lobLength);
+            }
+            else if (((Clob) c).isUnicodeStream()) {
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCMIXED;
+              lidAndLengths[i][1] = buildPlaceholderLength(lobLength);
+            }
+            else if (((Clob) c).isAsciiStream()) {
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCSBCS;
+              lidAndLengths[i][1] = buildPlaceholderLength(lobLength);
+            }
+            else if (((Clob) c).isString()) {
+              lidAndLengths[i][0] = FdocaConstants.PROTOCOL_TYPE_NLOBCMIXED;
+              lidAndLengths[i][1] = buildPlaceholderLength(((Clob) c).getUTF8Length());
+            }
+          }
+          break;
+        default :
+          throw new SqlException(netAgent_.logWriter_, "unrecognized sql type");
+      }
+
+      if (!parameterMetaData.nullable_[i])
+        lidAndLengths[i][0]--;
+    }
+    return overrideMap;
+  }
+
+  private int buildPlaceholderLength (long totalLength)
+  {
+    if (totalLength < 0x7fff)
+      return 0x8002; // need 2 bytes
+    else if (totalLength < 0x7fffffff)
+      return 0x8004; // need 4 bytes
+    else if (totalLength < 0x7fffffffffffL)
+      return 0x8006;
+    else
+      return 0x8008; // need 8 bytes
+  }
+
+  // Output Expected indicates wheterh the requester expects the target
+  // SQLAM to return output with an SQLDTARD reply data object
+  // as a result of the execution of the referenced SQL statement.
+  // this is a single byte.
+  // there are two possible enumerated values:
+  // 0x'F1' (CodePoint.TRUE) - for true indicating the requester expects output
+  // 0x'F0' (CodePoint.FALSE) - for false indicating the requeser does not expect output
+  // 0x'F0' is the default.
+  //
+  // preconditions:
+  //   sqlam must support this parameter on the command, method will not check.
+  private void buildOUTEXP (boolean outputExpected) throws SqlException
+  {
+    if (outputExpected)
+      writeScalar1Byte (CodePoint.OUTEXP, CodePoint.TRUE);
+  }
+
+  // Maximum Number of Extra Blocks specifies a limit on the number of extra
+  // blocks of answer set data per result set that the requester is capable of
+  // receiveing.
+  // this value must be able to be contained in a two byte signed number.
+  // there is a minimum value of 0.
+  // a zero indicates that the requester is not capable of receiving extra
+  // query blocks of answer set data.
+  // there is a SPCVAL of -1.
+  // a value of -1 indicates that the requester is capable of receiving
+  // the entire result set.
+  //
+  // preconditions:
+  //   sqlam must support this parameter on the command, method will not check.
+  void buildMAXBLKEXT (int maxNumOfExtraBlocks) throws SqlException
+  {
+    if (maxNumOfExtraBlocks != 0)
+      writeScalar2Bytes (CodePoint.MAXBLKEXT, maxNumOfExtraBlocks);
+  }
+
+  // preconditions:
+  void buildQRYROWSET (int fetchSize) throws SqlException
+  {
+    writeScalar4Bytes (CodePoint.QRYROWSET, fetchSize);
+  }
+
+  // The Procedure Name.
+  // The default value of PRCNAM is the procedure name value contained
+  // within the section identified by the pkgnamcsn parameter.  If that
+  // value is null, then the prcnam parameter must be specified.
+  // it has a max length of 255.
+  // the prcnam is required on commands if the procedure name is
+  // specified by a host variable.
+  // the default value is the procedure name contained in the section
+  // specified by the pkgnamcsn parameter on the EXCSQLSTT command.
+  //
+  // preconditions:
+  //   sqlam must support this parameter for the command, method will not check.
+  //   prcnam can not be null, SQLException will be thrown
+  //   prcnam can not be 0 length or > 255 length, SQLException will be thrown.
+  private void buildPRCNAM (String prcnam) throws SqlException
+  {
+    if (prcnam == null)
+      throw new SqlException (netAgent_.logWriter_, "null procedure name not supported");
+
+    int prcnamLength = prcnam.length();
+    if ((prcnamLength == 0) || (prcnamLength > 255))
+      throw new SqlException (netAgent_.logWriter_, "procedure name length, " + prcnamLength + ", is not allowed.");
+
+    writeScalarString (CodePoint.PRCNAM, prcnam);
+  }
+
+
+  // Query Block Size specifies the query block size for the reply
+  // data objects and the reply messages being returned from this command.
+  // this is a 4 byte unsigned binary number.
+  // the sqlam 6 min value is 512 and max value is 32767.
+  // this value was increased in later sqlam levels.
+  // until the code is ready to support larger query block sizes,
+  // it will always use DssConstants.MAX_DSS_LEN which is 32767.
+  //
+  // preconditions:
+  //   sqlam must support this parameter for the command, method will not check.
+  void buildQRYBLKSZ () throws SqlException
+  {
+    writeScalar4Bytes (CodePoint.QRYBLKSZ, DssConstants.MAX_DSS_LEN);
+  }
+
+  // Maximum Result Set Count specifies a limit on the number of result sets
+  // the requester is capable of receiving as reply data in response to an ECSQLSTT
+  // command that invokes a stored procedure.  If the stored procedure generates
+  // more than MAXRSLCNT result sets, then the target system returns at most, the first
+  // MAXRSLCNT of these result sets.  The stored procedure defines the order
+  // in which the target system returns result sets.
+  // this is s two byte signed binary number.
+  // it has a min value of 0 which indicates the requester is not capable
+  // of receiving result sets as reply data in response to the command.
+  // a special value, -1 (CodePoint.MAXRSLCNT_NOLIMIT = 0xffff), indicates the
+  // requester is capable of receiving all result sets in response the EXCSQLSTT.
+  //
+  // preconditions:
+  //   sqlam must support this parameter for the command, method will not check.
+  //   the value must be in correct range (-1 to 32767), method will not check.
+  private void buildMAXRSLCNT (int maxResultSetCount) throws SqlException
+  {
+    if (maxResultSetCount == 0)
+      return;
+    writeScalar2Bytes (CodePoint.MAXRSLCNT, maxResultSetCount);
+  }
+
+  // RDB Commit Allowed specifies whether an RDB should allow the processing of any
+  // commit or rollback operations that occure during execution of a statement.
+  // True allow the processing of commits and rollbacks
+  private void buildRDBCMTOK () throws SqlException
+  {
+    writeScalar1Byte (CodePoint.RDBCMTOK, CodePoint.TRUE);
+  }
+
+  // Result Set Flags is a single byte where each bit it a boolean flag.
+  // It specifies wheter the requester desires the server to return name,
+  // label and comment information for the columns of result sets generated by the command.
+  // The default is b'00000000'.
+  // columnNamesRequired
+  //    false means the requester does not desire column names returned.
+  //    true means the requester desires column names returned.
+  // columnLabelsRequired
+  //    false means the requester does not desire column labels returned.
+  //    true means the requester desires column labels returned.
+  // columnCommentsRequired
+  //    false means the requester does not desire column comments returned.
+  //    true means the requester desired column comments returned.
+  // cantProcessAnswerSetData
+  //    false means that for each result set, the requester expects the command
+  //    to return an FDOCA description of the answer set data and to possibly
+  //    return answer set data.  the block containing the end of the description
+  //    may be completed if room exists with answer set data.  additional blocks
+  //    of answer set data may also be chained to the block containing the end of the
+  //    FDOCA description.  up to the maximum number of extra blocks of answer set data
+  //    per result set specified in the MAXBLKEXT parameter.
+  //    true means that for each result set, the requester expects the command to return
+  //    an FDOCA description of the answer set data but does not expect the command to
+  //    return any answer set data.
+  // at SQLAM 7, new flags are supported which can be used to return
+  // standard, extended, and light sqlda
+  //
+  // preconditions:
+  //    sqlam must support this parameter, method will not check.
+  private void buildRSLSETFLG (int resultSetFlag) throws SqlException
+  {
+    writeScalar1Byte (CodePoint.RSLSETFLG, resultSetFlag);
+  }
+
+  void buildQRYINSID (long qryinsid) throws SqlException
+  {
+    markLengthBytes(CodePoint.QRYINSID);
+    writeLong(qryinsid);
+    updateLengthBytes();
+  }
+
+
+ // Return SQL Descriptor Area controls whether to return
+ // an SQL descriptor area that applies to the SQL statement this command
+ // identifies.  The target SQLAM obtains the SQL descriptor area by performing
+ // an SQL DESCRIBE function on the statement after the statement has been
+ // prepared.
+ // The value TRUE, X'F1' (CodePoint.TRUE), indicates an SQLDA is returned
+ // The value FALSE, X'F0' (CodePoint.FALSE), default, indicates an SQLDA is not returned.
+ //
+ // preconditions:
+ //   sqlam must support this parameter for the command, method will not check.
+  private void buildRTNSQLDA () throws SqlException
+  {
+    writeScalar1Byte (CodePoint.RTNSQLDA, CodePoint.TRUE);
+  }
+
+  // Type of SQL Descriptor Area.
+  // This is a single byte signed number that specifies the type of sqlda to
+  // return for the command.
+  // below sqlam 7 there were two possible enumerated values for this parameter.
+  // 0 (CodePoint.TYPSQLDA_STD_OUTPUT)- the default, indicates return the output sqlda.
+  // 1 (CodePoint.TYPSQLDA_STD_INPUT) - indicates return the input sqlda.
+  // the typsqlda was enhanced at sqlam 7 to support extened describe.
+  // at sqlam 7 the following enumerated values are supported.
+  // 0 (CodePoint.TYPSQLDA_STD_OUTPUT) - the default, standard output sqlda.
+  // 1 (CodePoint.TYPSQLDA_STD_INPUT) - standard input sqlda.
+  // 2 (CodePoint.TYPSQLDA_LIGHT_OUTPUT) - light output sqlda.
+  // 3 (CodePoint.TYPSQLDA_LIGHT_INPUT) - light input sqlda.
+  // 4 (CodePoint.TYPSQLDA_X_OUTPUT) - extended output sqlda.
+  // 5 (CodePoint.TYPSQLDA_X_INPUT) - extended input sqlda.
+  //
+  // preconditions:
+  //   sqlam or prdid must support this, method will not check.
+  //   valid enumerated type must be passed to method, method will not check.
+  private void buildTYPSQLDA (int typeSqlda) throws SqlException
+  {
+    // possibly inspect typeSqlda value and verify against sqlam level
+    if (typeSqlda != CodePoint.TYPSQLDA_STD_OUTPUT)
+      writeScalar1Byte (CodePoint.TYPSQLDA, typeSqlda);
+  }
+
+
+  // helper method to buildFDODTA to build the actual data length
+  private void setFDODTALobLength (int[][] protocolTypesAndLengths, int i, long dataLength) throws SqlException
+  {
+    if (protocolTypesAndLengths[i][1] == 0x8002)
+      writeShort ((short) dataLength);
+    else if (protocolTypesAndLengths[i][1] == 0x8004)
+      writeInt ((int) dataLength);  // 4 bytes to encode the length
+    else if (protocolTypesAndLengths[i][1] == 0x8006)// 6 bytes to encode the length
+      writeLong (dataLength);
+      //throw new SqlException (netAgent_.logWriter_, "0x8006 lob place holders not yet supported");
+    else if (protocolTypesAndLengths[i][1] == 0x8008)// 8 bytes to encode the length
+      writeLong (dataLength);
+
+    if (dataLength != 0) {
+      if (extdtaPositions_ == null)
+        extdtaPositions_ = new java.util.ArrayList();
+      extdtaPositions_.add (new Integer(i));
+    }
+  }
+
+  private boolean checkSendQryrowset (int fetchSize,
+                                      int resultSetType)
+  {
+    // if the cursor is forward_only, ignore the fetchSize and let the server return
+    // as many rows as fit in the query block.
+    // if the cursor is scrollable, send qryrowset if it is supported by the server
+    boolean sendQryrowset = false;
+    if (resultSetType != java.sql.ResultSet.TYPE_FORWARD_ONLY) {
+      sendQryrowset = true;
+    }
+    return sendQryrowset;
+  }
+
+  private int checkFetchsize (int fetchSize, int resultSetType)
+  {
+    // if fetchSize is not set for scrollable cursors, set it to the default fetchSize
+    if (resultSetType != java.sql.ResultSet.TYPE_FORWARD_ONLY && fetchSize == 0) {
+      fetchSize = org.apache.derby.client.am.Configuration.defaultFetchSize;
+    }
+    return fetchSize;
+  }
+
+  private int calculateResultSetFlags ()
+  {
+      return CodePoint.RSLSETFLG_EXTENDED_SQLDA;
+  }
+
+  public void writeSetSpecialRegister (java.util.ArrayList sqlsttList) throws SqlException
+  {
+    Section section =
+      netAgent_.sectionManager_.getDynamicSection(java.sql.ResultSet.HOLD_CURSORS_OVER_COMMIT);
+
+    buildEXCSQLSET (section);
+
+    // SQLSTT:
+    for (int i = 0; i < sqlsttList.size(); i++) {
+      buildSQLSTTcommandData ((String)sqlsttList.get(i));
+    }
+  }
+
+  private int[][] allocateLidAndLengthsArray (ColumnMetaData parameterMetaData)
+  {
+    int numVars = parameterMetaData.columns_;
+    int[][] lidAndLengths = parameterMetaData.protocolTypesCache_;
+    if ((lidAndLengths) == null || (lidAndLengths.length != numVars)) {
+      lidAndLengths = new int[numVars][2];
+      parameterMetaData.protocolTypesCache_ = lidAndLengths;
+    }
+    return lidAndLengths;
+  }
+
+  private void buildMddOverrides (java.util.ArrayList sdaOverrides) throws SqlException
+  {
+    byte[] mddBytes;
+    for (int i = 0; i < sdaOverrides.size(); i++) {
+      mddBytes = (byte[]) (sdaOverrides.get(i));
+      writeBytes (mddBytes);
+    }
+  }
+
+  private int getNextOverrideLid ()
+  {
+    return overrideLid_++;
+  }
+}
+
+

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetStatementRequest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXACallInfo.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXACallInfo.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXACallInfo.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXACallInfo.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,157 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.NetXACallInfo
+
+   Copyright (c) 2002, 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.
+
+*/
+/**********************************************************************
+ *
+ *
+ *  Component Name =
+ *
+ *  Package Name = org.apache.derby.client.net
+ *
+ *  Descriptive Name = XACallInfo class
+ *
+ *  Function = Handle XA information
+ *
+ *  List of Classes
+ *              - NetXACallInfo
+ *
+ *  Restrictions : None
+ *
+ **********************************************************************/
+package org.apache.derby.client.net;
+
+import javax.transaction.xa.*;
+import org.apache.derby.client.am.Connection;
+
+public class NetXACallInfo
+{
+  Xid xid_;                         // current xid
+  int xaFlags_;                     // current xaFlags
+  int xaState_;                     // used as a save area when switching connection
+                                    // may not be needed!!!~~~
+  int xaFunction_;                  // queued XA function being performed
+  int xaRetVal_;                    // xaretval from server
+  boolean xaInProgress_;            // set at start(), reset at commit(),
+                                    //  rollback(), or prepare() on RDONLY
+  boolean xaWasSuspended;           // used to indicate an XA tyrans was suspended
+                                    //  one or more times, overrides empty transaction
+  boolean currConnection_;          // set when actualConn_ is the current connection
+  boolean freeEntry_;               // set when no actualConn_, entry is free / available
+  boolean convReleased_;            // release coversation, reuse successfull = true
+  NetXAResource xaResource_;         // NetXAResource containing this NetXACallInfo
+  NetXAConnection actualConn_; // the actual connection object, not necessarily
+                                    // the user's connection object
+  /* only the first connection object is actually used. The other connection
+   * objects are used only for their TCP/IP variables to simulate
+   * suspend / resume
+   */
+
+  private byte[] crrtkn_;
+  private java.io.InputStream in_;
+  private java.io.OutputStream out_;
+
+  private byte[] uowid_;  // Unit of Work ID
+
+  private boolean readOnlyTransaction_;  // readOnlyTransaction Flag
+
+  public NetXACallInfo()
+  {
+    xid_ = null;
+    xaFlags_ = XAResource.TMNOFLAGS;
+    xaState_ = Connection.XA_OPEN_IDLE;
+    xaInProgress_ = false;
+    currConnection_ = false;
+    freeEntry_ = true;
+    convReleased_ = false;
+    actualConn_ = null;
+    readOnlyTransaction_ = true;
+    xaResource_ = null;
+    xaRetVal_ = 0;
+    xaWasSuspended = false;
+  }
+
+  public NetXACallInfo( Xid xid, int flags, int state,
+                       NetXAResource xares, NetXAConnection actualConn )
+  {
+    xid_ = xid;
+    xaFlags_ = flags;
+    xaState_ = state;
+    xaInProgress_ = false;
+    currConnection_ = false;
+    freeEntry_ = true;
+    actualConn_ = actualConn;
+    readOnlyTransaction_ = true;
+    xaResource_ = xares;
+    xaRetVal_ = 0;
+    xaWasSuspended = false;
+  }
+
+  public void saveConnectionVariables()
+  {
+    in_ = actualConn_.getInputStream();
+    out_ = actualConn_.getOutputStream();
+    crrtkn_ = actualConn_.getCorrelatorToken();
+  }
+
+  public java.io.InputStream getInputStream()
+  {
+    return in_;
+  }
+
+  public java.io.OutputStream getOutputStream()
+  {
+    return out_;
+  }
+
+  public byte[] getCorrelatorToken()
+  {
+    return crrtkn_;
+  }
+
+  protected void setUOWID(byte[] uowid)
+  {
+    uowid_ = uowid;
+  }
+
+  protected byte[] getUOWID()
+  {
+    return uowid_;
+  }
+
+  protected void setReadOnlyTransactionFlag(boolean flag)
+  {
+    readOnlyTransaction_ = flag;
+  }
+
+  protected boolean getReadOnlyTransactionFlag()
+  {
+    return readOnlyTransaction_;
+  }
+
+
+}
+
+
+
+
+
+
+
+
+

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXACallInfo.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnection.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnection.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnection.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnection.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,274 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.NetXAConnection
+
+   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.net;
+
+import org.apache.derby.client.am.SqlException;
+import org.apache.derby.client.am.Statement;
+import javax.transaction.xa.*;
+
+public class NetXAConnection extends org.apache.derby.client.net.NetConnection
+{
+  //---------------------constructors/finalizer---------------------------------
+  // For XA Connections
+  public NetXAConnection (NetLogWriter netLogWriter,
+                         String user,
+                         String password,
+                         org.apache.derby.jdbc.ClientDataSource dataSource,
+                         int rmId,
+                         boolean isXAConn) throws SqlException
+  {
+    super (netLogWriter, user, password, dataSource, rmId, isXAConn);
+    checkPlatformVersion();
+  }
+
+  protected void finalize () throws java.lang.Throwable
+  {
+    super.finalize();
+  }
+
+  public void setCorrelatorToken(byte[] crttoken)
+  {
+    crrtkn_ = crttoken;
+  }
+
+  public byte[] getCorrelatorToken()
+  {
+    return crrtkn_;
+  }
+
+  void setNetXAResource( NetXAResource xares )
+  {
+    xares_ = xares;
+  }
+
+  public void writeLocalXAStart_ () throws SqlException
+  { netAgent_.netConnectionRequest_.writeLocalXAStart (this); }
+  public void readLocalXAStart_ () throws SqlException
+  { netAgent_.netConnectionReply_.readLocalXAStart (this); }
+
+  public void writeLocalXACommit_ () throws SqlException
+  {  netAgent_.netConnectionRequest_.writeLocalXACommit (this); }
+  public void readLocalXACommit_ () throws SqlException
+  { netAgent_.netConnectionReply_.readLocalXACommit (this); }
+
+  public void writeLocalXARollback_ () throws SqlException
+  {  netAgent_.netConnectionRequest_.writeLocalXARollback (this); }
+  public void readLocalXARollback_ () throws SqlException
+  { netAgent_.netConnectionReply_.readLocalXARollback (this); }
+
+  public void writeTransactionStart(Statement statement) throws SqlException
+  {
+	  //KATHEY  remove below after checking that we don't need it.
+    if( !isXAConnection_ )
+      return; // not a XA connection
+
+    // this is a XA connection
+    int xaState = getXAState();
+    xares_.exceptionsOnXA = null;
+
+    if( xaState == XA_RECOVER )
+    { // in recover, clean up and go to open-idle
+      if (indoubtTransactions_ != null)
+      {
+        indoubtTransactions_.clear();
+        indoubtTransactions_ = null;
+        setXAState( XA_OPEN_IDLE );
+        xaState = XA_OPEN_IDLE;
+      }
+    }
+	// For derby we don't need to write transaction start for a local 
+	//transaction.  If autocommit is off we are good to go.
+	return;
+  }
+
+  public void setIndoubtTransactions(java.util.Hashtable indoubtTransactions)
+  {
+    if (indoubtTransactions_ != null)
+      indoubtTransactions_.clear();
+    indoubtTransactions_ = indoubtTransactions;
+  }
+
+  public byte[] getUOWID(Xid xid)
+  {
+    NetIndoubtTransaction indoubtTxn = (NetIndoubtTransaction) indoubtTransactions_.get(xid);
+    if( indoubtTxn == null )
+      return null;
+    byte[] uowid = indoubtTxn.getUOWID();
+    return uowid;
+  }
+
+
+  public int getPort(Xid xid)
+  {
+    NetIndoubtTransaction indoubtTxn = (NetIndoubtTransaction) indoubtTransactions_.get(xid);
+    if( indoubtTxn == null )
+      return -1;
+    return indoubtTxn.getPort();
+  }
+
+  public void writeCommit () throws SqlException
+  {
+    // this logic must be in sync with willAutoCommitGenerateFlow() logic
+    if (isXAConnection_)
+    { // XA Connection
+      int xaState = getXAState();
+      if ((xaState == XA_OPEN_IDLE) ||
+          (xaState == XA_LOCAL) ||
+          (xaState == XA_LOCAL_START_SENT))
+      {
+          xares_.callInfoArray_[xares_.conn_.currXACallInfoOffset_].xid_ =
+              xares_.nullXid;
+          writeLocalXACommit_();
+	  }
+    }
+    else
+    { // not XA connection
+      writeLocalCommit_();
+    }
+  }
+
+  public void readCommit () throws SqlException
+  {
+    if (isXAConnection_)
+    { // XA Connection
+      int xaState = getXAState();
+      NetXACallInfo callInfo = xares_.callInfoArray_[currXACallInfoOffset_];
+      callInfo.xaRetVal_ = NetXAResource.XARETVAL_XAOK; // initialize XARETVAL
+      if ((xaState == XA_OPEN_IDLE) ||
+           (xaState == XA_LOCAL) ||
+           (xaState == XA_LOCAL_START_SENT))
+      {
+         readLocalXACommit_();
+         setXAState( XA_OPEN_IDLE );
+      }
+      if( callInfo.xaRetVal_ != NetXAResource.XARETVAL_XAOK )
+      { // xaRetVal has possible error, format it
+         callInfo.xaFunction_ = NetXAResource.XAFUNC_COMMIT;
+         xares_.xaRetValErrorAccumSQL( callInfo, 0 );
+         callInfo.xaRetVal_ = NetXAResource.XARETVAL_XAOK; // re-initialize XARETVAL
+         throw xares_.exceptionsOnXA;
+      }
+    }
+    else
+      // non-XA connections
+      readLocalCommit_();
+  }
+
+  public void writeRollback () throws SqlException
+  {
+    if (isXAConnection_)
+    {
+         xares_.callInfoArray_[xares_.conn_.currXACallInfoOffset_].xid_ =
+                xares_.nullXid;
+         writeLocalXARollback_();
+    }
+    else
+      writeLocalRollback_(); // non-XA
+  }
+
+  public void readRollback() throws SqlException
+  {
+    if (isXAConnection_)
+    { // XA connections
+        NetXACallInfo callInfo = xares_.callInfoArray_[currXACallInfoOffset_];
+        callInfo.xaRetVal_ = NetXAResource.XARETVAL_XAOK; // initialize XARETVAL
+        readLocalXARollback_();
+
+        if( callInfo.xaRetVal_ != NetXAResource.XARETVAL_XAOK )
+        { // xaRetVal has possible error, format it
+          callInfo.xaFunction_ = NetXAResource.XAFUNC_ROLLBACK;
+          xares_.xaRetValErrorAccumSQL( callInfo, 0 );
+          callInfo.xaRetVal_ = NetXAResource.XARETVAL_XAOK; // re-initialize XARETVAL
+          throw xares_.exceptionsOnXA;
+        }
+
+
+      // for all XA connectiions
+      setXAState( XA_OPEN_IDLE );
+    }
+    else
+      readLocalRollback_(); // non-XA connections
+  }
+
+  synchronized public void close () throws SqlException
+  {
+    // call super.close*() to do the close*
+    super.close();
+    if (open_) return; // still open, return
+    if( xares_ != null )
+    {
+      xares_.removeXaresFromSameRMchain();
+    }
+  }
+
+  synchronized public void closeX () throws SqlException
+  {
+    // call super.close*() to do the close*
+    super.closeX();
+    if (open_) return; // still open, return
+    if( xares_ != null )
+    {
+      xares_.removeXaresFromSameRMchain();
+    }
+  }
+
+  synchronized public void closeForReuse() throws SqlException
+  {
+    // call super.close*() to do the close*
+    super.closeForReuse();
+    if (open_) return; // still open, return
+    if( xares_ != null )
+    {
+      xares_.removeXaresFromSameRMchain();
+    }
+  }
+
+  synchronized public void closeResources () throws SqlException
+  {
+    // call super.close*() to do the close*
+    super.closeResources();
+    if (open_) return; // still open, return
+    if( xares_ != null )
+    {
+      xares_.removeXaresFromSameRMchain();
+    }
+  }
+
+  private void checkPlatformVersion() throws SqlException
+  {
+    int supportedVersion;
+
+    supportedVersion = 8;
+
+    if( xaHostVersion_ >= supportedVersion )
+    { // supported version, return
+      return;
+    }
+
+    // unsupported version for platform
+    String platform = null;
+    platform = "Linux, Unix, Windows";
+    String versionMsg = "On " + platform + " XA supports version " +
+                        supportedVersion + " and above, this is version " +
+                        xaHostVersion_;
+    throw new SqlException( agent_.logWriter_, versionMsg );
+  }
+}

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnection.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message