You are viewing a plain text version of this content. The canonical link for it is here.
Posted to derby-commits@db.apache.org by km...@apache.org on 2012/08/08 08:54:47 UTC
svn commit: r1370674 [8/12] - in
/db/derby/code/trunk/java/drda/org/apache/derby: drda/ impl/drda/
Modified: db/derby/code/trunk/java/drda/org/apache/derby/impl/drda/DRDAStatement.java
URL: http://svn.apache.org/viewvc/db/derby/code/trunk/java/drda/org/apache/derby/impl/drda/DRDAStatement.java?rev=1370674&r1=1370673&r2=1370674&view=diff
==============================================================================
--- db/derby/code/trunk/java/drda/org/apache/derby/impl/drda/DRDAStatement.java (original)
+++ db/derby/code/trunk/java/drda/org/apache/derby/impl/drda/DRDAStatement.java Wed Aug 8 06:54:46 2012
@@ -43,60 +43,60 @@ import org.apache.derby.iapi.util.String
import org.apache.derby.impl.jdbc.Util;
/**
- DRDAStatement stores information about the statement being executed
+ DRDAStatement stores information about the statement being executed
*/
class DRDAStatement
{
- //NOTE!
- //
- // Since DRDAStatements are reused, ALL variables (except those noted in
- // the comments for reset method) should be set to their default values
- // in reset().
-
-
- protected String typDefNam; //TYPDEFNAM for this statement
- protected int byteOrder; //deduced from typDefNam, save String comparisons
- protected int ccsidSBC; //CCSID for single byte characters
- protected int ccsidDBC; //CCSID for double byte characters
- protected int ccsidMBC; //CCSID for mixed byte characters
- protected String ccsidSBCEncoding; //Java encoding for CCSIDSBC
- protected String ccsidDBCEncoding; //Java encoding for CCSIDDBC
- protected String ccsidMBCEncoding; //Java encoding for CCSIDMBC
-
- protected Database database; // Database this statement is created for
- private Pkgnamcsn pkgnamcsn; // Package name/section # and consistency token
- protected ConsistencyToken pkgcnstkn; // Consistency token for the first result set
- protected String pkgid; // package id
- protected int pkgsn; // section number
- int withHoldCursor = -1; // hold cursor after commit attribute.
- protected int isolationLevel; //JCC isolation level for Statement
- protected String cursorName;
- protected int scrollType = ResultSet.TYPE_FORWARD_ONLY; // Sensitive or Insensitive scroll attribute
- protected int concurType = ResultSet.CONCUR_READ_ONLY;; // Concurency type
- protected long rowCount; // Number of rows we have processed
- protected byte [] rslsetflg; // Result Set Flags
- protected int maxrslcnt; // Maximum Result set count
- protected PreparedStatement ps; // Prepared statement
- protected ParameterMetaData stmtPmeta; // param metadata
- protected boolean isCall;
- protected String procName; // callable statement's method name
- private int[] outputTypes; // jdbc type for output parameter or NOT_OUTPUT_PARAM
- // if not an output parameter.
- private int[] outputPrecision;
- private int[] outputScale;
+ //NOTE!
+ //
+ // Since DRDAStatements are reused, ALL variables (except those noted in
+ // the comments for reset method) should be set to their default values
+ // in reset().
+
+
+ protected String typDefNam; //TYPDEFNAM for this statement
+ protected int byteOrder; //deduced from typDefNam, save String comparisons
+ protected int ccsidSBC; //CCSID for single byte characters
+ protected int ccsidDBC; //CCSID for double byte characters
+ protected int ccsidMBC; //CCSID for mixed byte characters
+ protected String ccsidSBCEncoding; //Java encoding for CCSIDSBC
+ protected String ccsidDBCEncoding; //Java encoding for CCSIDDBC
+ protected String ccsidMBCEncoding; //Java encoding for CCSIDMBC
+
+ protected Database database; // Database this statement is created for
+ private Pkgnamcsn pkgnamcsn; // Package name/section # and consistency token
+ protected ConsistencyToken pkgcnstkn; // Consistency token for the first result set
+ protected String pkgid; // package id
+ protected int pkgsn; // section number
+ int withHoldCursor = -1; // hold cursor after commit attribute.
+ protected int isolationLevel; //JCC isolation level for Statement
+ protected String cursorName;
+ protected int scrollType = ResultSet.TYPE_FORWARD_ONLY; // Sensitive or Insensitive scroll attribute
+ protected int concurType = ResultSet.CONCUR_READ_ONLY;; // Concurency type
+ protected long rowCount; // Number of rows we have processed
+ protected byte [] rslsetflg; // Result Set Flags
+ protected int maxrslcnt; // Maximum Result set count
+ protected PreparedStatement ps; // Prepared statement
+ protected ParameterMetaData stmtPmeta; // param metadata
+ protected boolean isCall;
+ protected String procName; // callable statement's method name
+ private int[] outputTypes; // jdbc type for output parameter or NOT_OUTPUT_PARAM
+ // if not an output parameter.
+ private int[] outputPrecision;
+ private int[] outputScale;
- protected static int NOT_OUTPUT_PARAM = -100000;
- protected boolean outputExpected; // expect output from a callable statement
- private Statement stmt; // SQL statement
+ protected static int NOT_OUTPUT_PARAM = -100000;
+ protected boolean outputExpected; // expect output from a callable statement
+ private Statement stmt; // SQL statement
- private DRDAResultSet currentDrdaRs; // Current ResultSet
+ private DRDAResultSet currentDrdaRs; // Current ResultSet
/** Hashtable with resultsets. */
private Hashtable<ConsistencyToken, DRDAResultSet> resultSetTable;
/** Ordered list of hash keys. */
private ArrayList<ConsistencyToken> resultSetKeyList;
- private int numResultSets = 0;
+ private int numResultSets = 0;
/**
* A chain of warnings indicating whether some of the data values returned
@@ -104,180 +104,180 @@ class DRDAStatement
*/
private DataTruncation truncationWarnings;
- /** This class is used to keep track of the statement's parameters
- * as they are received from the client. It uses arrays to track
- * the DRDA type, the length in bytes and the externalness of each
- * parameter. Arrays of int/byte are used rather than ArrayLists
- * of Integer/Byte in order to re-use the same storage each time
- * the statement is executed. */
- private static class DrdaParamState {
- // The last parameter may be streamed.
- // We need to keep a record of it so we can drain it if it is not
- // used.
- // Only the last parameter with an EXTDTA will be streamed.
- //(See DRDAConnThread.readAndSetAllExtParams()).
- private EXTDTAReaderInputStream streamedParameter = null;
- private int typeLstEnd_ = 0;
- private byte[] typeLst_ = new byte[10];
- private int[] lenLst_ = new int[10];
- private int extLstEnd_ = 0;
- private int[] extLst_ = new int[10];
-
- private static Object growArray(Object array) {
- final int oldLen = Array.getLength(array);
- Object tmp =
- Array.newInstance(array.getClass().getComponentType(),
- Math.max(oldLen,1)*2);
- System.arraycopy(array, 0, tmp, 0, oldLen);
- return tmp;
- }
-
- /**
- * <code>clear</code> resets the arrays so that new parameters
- * will be added at the beginning. No initialization or
- * releasing of storage takes place unless the trim argument
- * is true.
- *
- * @param trim - if true; release excess storage
- */
- protected void clear(boolean trim) {
- streamedParameter = null;
- typeLstEnd_ = 0;
- extLstEnd_ = 0;
- if (trim && typeLst_.length > 10) {
- typeLst_ = new byte[10];
- lenLst_ = new int[10];
- extLst_ = new int[10];
- }
- }
-
- /**
- * <code>addDrdaParam</code> adds a new parameter with its
- * DRDA type and byte length. The arrays are automatically
- * grown if needed.
- *
- * @param t a <code>byte</code> value, the DRDA type of the
- * parameter being added
- * @param s an <code>int</code> value, the length in bytes of
- * the parameter being added
- */
- protected void addDrdaParam(byte t, int s) {
- if (typeLstEnd_ >= typeLst_.length) {
- typeLst_ = (byte[])growArray(typeLst_);
- lenLst_ = (int[])growArray(lenLst_);
- }
- typeLst_[typeLstEnd_] = t;
- lenLst_[typeLstEnd_] = s;
- ++typeLstEnd_;
- }
-
- /**
- * <code>getDrdaParamCount</code> return the number of
- * parameters added so far (since last clear).
- *
- * @return an <code>int</code> value, the number of parameters
- */
- protected int getDrdaParamCount() { return typeLstEnd_; }
-
- /**
- * <code>getDrdaType</code> returns a byte that represents the
- * DRDA type of the ith parameter.
- *
- * @param i an <code>int</code> value, a parameter position
- * (zero-based)
- * @return a <code>byte</code> value, the DRDA type
- */
- protected byte getDrdaType(int i) { return typeLst_[i]; }
-
- /**
- * <code>getDrdaLen</code> returns the length in bytes of the
- * ith parameter.
- *
- * @param i an <code>int</code> value, a parameter position
- * (zero-based)
- * @return an <code>int</code> value
- */
- protected int getDrdaLen(int i) { return lenLst_[i]; }
-
- /**
- * <code>addExtPos</code> marks parameter i as external. The
- * array is grown as needed.
- *
- * @param p an <code>int</code> value, a parameter position
- * (zero-based)
- */
- protected void addExtPos(int p) {
- if (extLstEnd_ >= extLst_.length) {
- extLst_ = (int[])growArray(extLst_);
- }
- extLst_[extLstEnd_] = p;
- ++extLstEnd_;
- }
-
- /**
- * <code>getExtPosCount</code> returns the number of
- * parameters marked as external so far (since last clear).
- *
- * @return an <code>int</code> value, the number of external
- * parameters.
- */
- protected int getExtPosCount() { return extLstEnd_; }
-
- /**
- * <code>getExtPos</code> returns the actual parameter position
- * of the ith external parameter.
- *
- * @param i an <code>int</code> value, index into the list of
- * external parameters, zero-based
- * @return an <code>int</code> value, the parameter position
- * of the ith external parameter (zero-based)
- */
- protected int getExtPos(int i) { return extLst_[i]; }
+ /** This class is used to keep track of the statement's parameters
+ * as they are received from the client. It uses arrays to track
+ * the DRDA type, the length in bytes and the externalness of each
+ * parameter. Arrays of int/byte are used rather than ArrayLists
+ * of Integer/Byte in order to re-use the same storage each time
+ * the statement is executed. */
+ private static class DrdaParamState {
+ // The last parameter may be streamed.
+ // We need to keep a record of it so we can drain it if it is not
+ // used.
+ // Only the last parameter with an EXTDTA will be streamed.
+ //(See DRDAConnThread.readAndSetAllExtParams()).
+ private EXTDTAReaderInputStream streamedParameter = null;
+ private int typeLstEnd_ = 0;
+ private byte[] typeLst_ = new byte[10];
+ private int[] lenLst_ = new int[10];
+ private int extLstEnd_ = 0;
+ private int[] extLst_ = new int[10];
+
+ private static Object growArray(Object array) {
+ final int oldLen = Array.getLength(array);
+ Object tmp =
+ Array.newInstance(array.getClass().getComponentType(),
+ Math.max(oldLen,1)*2);
+ System.arraycopy(array, 0, tmp, 0, oldLen);
+ return tmp;
+ }
+
+ /**
+ * <code>clear</code> resets the arrays so that new parameters
+ * will be added at the beginning. No initialization or
+ * releasing of storage takes place unless the trim argument
+ * is true.
+ *
+ * @param trim - if true; release excess storage
+ */
+ protected void clear(boolean trim) {
+ streamedParameter = null;
+ typeLstEnd_ = 0;
+ extLstEnd_ = 0;
+ if (trim && typeLst_.length > 10) {
+ typeLst_ = new byte[10];
+ lenLst_ = new int[10];
+ extLst_ = new int[10];
+ }
+ }
+
+ /**
+ * <code>addDrdaParam</code> adds a new parameter with its
+ * DRDA type and byte length. The arrays are automatically
+ * grown if needed.
+ *
+ * @param t a <code>byte</code> value, the DRDA type of the
+ * parameter being added
+ * @param s an <code>int</code> value, the length in bytes of
+ * the parameter being added
+ */
+ protected void addDrdaParam(byte t, int s) {
+ if (typeLstEnd_ >= typeLst_.length) {
+ typeLst_ = (byte[])growArray(typeLst_);
+ lenLst_ = (int[])growArray(lenLst_);
+ }
+ typeLst_[typeLstEnd_] = t;
+ lenLst_[typeLstEnd_] = s;
+ ++typeLstEnd_;
+ }
+
+ /**
+ * <code>getDrdaParamCount</code> return the number of
+ * parameters added so far (since last clear).
+ *
+ * @return an <code>int</code> value, the number of parameters
+ */
+ protected int getDrdaParamCount() { return typeLstEnd_; }
+
+ /**
+ * <code>getDrdaType</code> returns a byte that represents the
+ * DRDA type of the ith parameter.
+ *
+ * @param i an <code>int</code> value, a parameter position
+ * (zero-based)
+ * @return a <code>byte</code> value, the DRDA type
+ */
+ protected byte getDrdaType(int i) { return typeLst_[i]; }
+
+ /**
+ * <code>getDrdaLen</code> returns the length in bytes of the
+ * ith parameter.
+ *
+ * @param i an <code>int</code> value, a parameter position
+ * (zero-based)
+ * @return an <code>int</code> value
+ */
+ protected int getDrdaLen(int i) { return lenLst_[i]; }
+
+ /**
+ * <code>addExtPos</code> marks parameter i as external. The
+ * array is grown as needed.
+ *
+ * @param p an <code>int</code> value, a parameter position
+ * (zero-based)
+ */
+ protected void addExtPos(int p) {
+ if (extLstEnd_ >= extLst_.length) {
+ extLst_ = (int[])growArray(extLst_);
+ }
+ extLst_[extLstEnd_] = p;
+ ++extLstEnd_;
+ }
+
+ /**
+ * <code>getExtPosCount</code> returns the number of
+ * parameters marked as external so far (since last clear).
+ *
+ * @return an <code>int</code> value, the number of external
+ * parameters.
+ */
+ protected int getExtPosCount() { return extLstEnd_; }
+
+ /**
+ * <code>getExtPos</code> returns the actual parameter position
+ * of the ith external parameter.
+ *
+ * @param i an <code>int</code> value, index into the list of
+ * external parameters, zero-based
+ * @return an <code>int</code> value, the parameter position
+ * of the ith external parameter (zero-based)
+ */
+ protected int getExtPos(int i) { return extLst_[i]; }
- /**
- * Read the rest of the streamed parameter if not consumed
- * by the executing statement. DERBY-3085
- * @throws IOException
- */
- protected void drainStreamedParameter() throws IOException
- {
- if (streamedParameter != null)
- {
- // we drain the buffer 1000 bytes at a time.
- // 1000 is just a random selection that doesn't take
- // too much memory. Perhaps something else would be
- // more efficient?
- byte[] buffer = new byte[1000];
- int i;
- do {
- i= streamedParameter.read(buffer,0,1000);
- } while (i != -1);
- }
- }
+ /**
+ * Read the rest of the streamed parameter if not consumed
+ * by the executing statement. DERBY-3085
+ * @throws IOException
+ */
+ protected void drainStreamedParameter() throws IOException
+ {
+ if (streamedParameter != null)
+ {
+ // we drain the buffer 1000 bytes at a time.
+ // 1000 is just a random selection that doesn't take
+ // too much memory. Perhaps something else would be
+ // more efficient?
+ byte[] buffer = new byte[1000];
+ int i;
+ do {
+ i= streamedParameter.read(buffer,0,1000);
+ } while (i != -1);
+ }
+ }
- public void setStreamedParameter(EXTDTAReaderInputStream eis) {
- streamedParameter = eis;
- }
-
- }
- private DrdaParamState drdaParamState_ = new DrdaParamState();
-
- // Query options sent on EXCSQLSTT
- // These the default for ResultSets created for this statement.
- // These can be overriden by OPNQRY or CNTQRY,
- protected int nbrrow; // number of fetch or insert rows
- protected int qryrowset; // Query row set
- protected int blksize; // Query block size
- protected int maxblkext; // Maximum number of extra blocks
- protected int outovropt; // Output Override option
- protected boolean qryrfrtbl; // Query refresh answer set table
- private int qryprctyp = CodePoint.QRYBLKCTL_DEFAULT; // Protocol type
-
-
+ public void setStreamedParameter(EXTDTAReaderInputStream eis) {
+ streamedParameter = eis;
+ }
+
+ }
+ private DrdaParamState drdaParamState_ = new DrdaParamState();
+
+ // Query options sent on EXCSQLSTT
+ // These the default for ResultSets created for this statement.
+ // These can be overriden by OPNQRY or CNTQRY,
+ protected int nbrrow; // number of fetch or insert rows
+ protected int qryrowset; // Query row set
+ protected int blksize; // Query block size
+ protected int maxblkext; // Maximum number of extra blocks
+ protected int outovropt; // Output Override option
+ protected boolean qryrfrtbl; // Query refresh answer set table
+ private int qryprctyp = CodePoint.QRYBLKCTL_DEFAULT; // Protocol type
+
+
- boolean needsToSendParamData = false;
- boolean explicitlyPrepared = false; //Prepared with PRPSQLSTT (reusable)
+ boolean needsToSendParamData = false;
+ boolean explicitlyPrepared = false; //Prepared with PRPSQLSTT (reusable)
/**
* If this changes, we need to re-send result set metadata to client, since
@@ -292,71 +292,71 @@ class DRDAStatement
*/
int sqldaType;
- // constructor
- /**
- * DRDAStatement constructor
- *
- * @param database
- *
- */
- DRDAStatement (Database database)
- {
- this.database = database;
- setTypDefValues();
- this.currentDrdaRs = new DRDAResultSet();
- }
-
- /**
- * set TypDef values
- *
- */
- protected void setTypDefValues()
- {
- // initialize statement values to current database values
- this.typDefNam = database.typDefNam;
- this.byteOrder = database.byteOrder;
- this.ccsidSBC = database.ccsidSBC;
- this.ccsidDBC = database.ccsidDBC;
- this.ccsidMBC = database.ccsidMBC;
- this.ccsidSBCEncoding = database.ccsidSBCEncoding;
- this.ccsidDBCEncoding = database.ccsidDBCEncoding;
- this.ccsidMBCEncoding = database.ccsidMBCEncoding;
- }
- /**
- * Set database
- *
- * @param database
- */
- protected void setDatabase(Database database)
- {
- this.database = database;
- setTypDefValues();
- }
- /**
- * Set statement
- *
- * @param conn Connection
- * @exception SQLException
- */
- protected void setStatement(Connection conn)
- throws SQLException
- {
- stmt = conn.createStatement();
- //beetle 3849 - see prepareStatement for details
- if (cursorName != null)
- stmt.setCursorName(cursorName);
- }
- /**
- * Get the statement
- *
- * @return statement
- * @exception SQLException
- */
- protected Statement getStatement()
- throws SQLException
- {
- return stmt;
- }
+ // constructor
+ /**
+ * DRDAStatement constructor
+ *
+ * @param database
+ *
+ */
+ DRDAStatement (Database database)
+ {
+ this.database = database;
+ setTypDefValues();
+ this.currentDrdaRs = new DRDAResultSet();
+ }
+
+ /**
+ * set TypDef values
+ *
+ */
+ protected void setTypDefValues()
+ {
+ // initialize statement values to current database values
+ this.typDefNam = database.typDefNam;
+ this.byteOrder = database.byteOrder;
+ this.ccsidSBC = database.ccsidSBC;
+ this.ccsidDBC = database.ccsidDBC;
+ this.ccsidMBC = database.ccsidMBC;
+ this.ccsidSBCEncoding = database.ccsidSBCEncoding;
+ this.ccsidDBCEncoding = database.ccsidDBCEncoding;
+ this.ccsidMBCEncoding = database.ccsidMBCEncoding;
+ }
+ /**
+ * Set database
+ *
+ * @param database
+ */
+ protected void setDatabase(Database database)
+ {
+ this.database = database;
+ setTypDefValues();
+ }
+ /**
+ * Set statement
+ *
+ * @param conn Connection
+ * @exception SQLException
+ */
+ protected void setStatement(Connection conn)
+ throws SQLException
+ {
+ stmt = conn.createStatement();
+ //beetle 3849 - see prepareStatement for details
+ if (cursorName != null)
+ stmt.setCursorName(cursorName);
+ }
+ /**
+ * Get the statement
+ *
+ * @return statement
+ * @exception SQLException
+ */
+ protected Statement getStatement()
+ throws SQLException
+ {
+ return stmt;
+ }
/**
* Add a warning about data having been truncated.
@@ -385,1219 +385,1219 @@ class DRDAStatement
truncationWarnings = null;
}
- /**Set resultSet defaults to match
- * the statement defaults sent on EXCSQLSTT
- * This might be overridden on OPNQRY or CNTQRY
- **/
-
- protected void setRsDefaultOptions(DRDAResultSet drs)
- {
- drs.nbrrow = nbrrow;
- drs.qryrowset = qryrowset;
- drs.blksize = blksize;
- drs.maxblkext = maxblkext;
- drs.outovropt = outovropt;
- drs.rslsetflg = rslsetflg;
- drs.scrollType = scrollType;
- drs.concurType = concurType;
- drs.setQryprctyp(qryprctyp);
- drs.qryrowset = qryrowset;
- }
-
- /**
- * Get the extData Objects
- *
- * @return ArrayList with extdta
- */
- protected ArrayList<Object> getExtDtaObjects()
- {
- return currentDrdaRs.getExtDtaObjects();
- }
-
- public void setSplitQRYDTA(byte []data)
- {
- currentDrdaRs.setSplitQRYDTA(data);
- }
- public byte[]getSplitQRYDTA()
- {
- return currentDrdaRs.getSplitQRYDTA();
- }
-
- /**
- * Add extDtaObject
- * @param o - object to add
- * @param jdbcIndex - jdbc index for parameter
- */
- protected void addExtDtaObject (Object o, int jdbcIndex )
- {
- currentDrdaRs.addExtDtaObject(o,jdbcIndex);
- }
-
-
- /**
- * Clear externalized lob objects in current result set
- */
- protected void clearExtDtaObjects ()
- {
- currentDrdaRs.clearExtDtaObjects();
- }
-
- /*
- * Is lob object nullable
- * @param index - offset starting with 0
- * @return true if object is nullable
- */
- protected boolean isExtDtaValueNullable(int index)
- {
- return currentDrdaRs.isExtDtaValueNullable(index);
- }
-
-
- /**
- * Set query options sent on OPNQRY and pass options down to the
- * current <code>DRDAResultSet</code> object.
- *
- * @param blksize QRYBLKSZ (Query Block Size)
- * @param qryblkctl QRYPRCTYP (Query Protocol Type)
- * @param maxblkext MAXBLKEXT (Maximum Number of Extra Blocks)
- * @param outovropt OUTOVROPT (Output Override Option)
- * @param qryrowset QRYROWSET (Query Rowset Size)
- * @param qryclsimpl QRYCLSIMP (Query Close Implicit)
- * @see DRDAResultSet#setOPNQRYOptions(int, int, int, int, int, int)
- */
- protected void setOPNQRYOptions(int blksize, int qryblkctl,
- int maxblkext, int outovropt,int qryrowset,int qryclsimpl)
- {
- this.blksize = blksize;
- this.qryprctyp = qryblkctl;
- this.maxblkext = maxblkext;
- this.outovropt = outovropt;
- this.qryrowset = qryrowset;
- currentDrdaRs.setOPNQRYOptions( blksize, qryblkctl, maxblkext,
- outovropt, qryrowset, qryclsimpl);
- }
-
- /*
- * Set query options sent on CNTQRY
- */
- protected void setQueryOptions(int blksize, boolean qryrelscr,
- long qryrownbr,
- boolean qryfrtbl,int nbrrow,int maxblkext,
- int qryscrorn, boolean qryrowsns,
- boolean qryblkrst,
- boolean qryrtndta,int qryrowset,
- int rtnextdta)
- {
- currentDrdaRs.blksize = blksize;
- currentDrdaRs.qryrelscr = qryrelscr;
- currentDrdaRs.qryrownbr = qryrownbr;
- currentDrdaRs.qryrfrtbl = qryrfrtbl;
- currentDrdaRs.nbrrow = nbrrow;
- currentDrdaRs.maxblkext = maxblkext;
- currentDrdaRs.qryscrorn = qryscrorn;
- currentDrdaRs.qryrowsns = qryrowsns;
- currentDrdaRs.qryblkrst = qryblkrst;
- currentDrdaRs.qryrtndta = qryrtndta;
- currentDrdaRs.qryrowset = qryrowset;
- currentDrdaRs.rtnextdta = rtnextdta;
- }
-
-
-
- protected void setQryprctyp(int qryprctyp)
- {
- this.qryprctyp = qryprctyp;
- currentDrdaRs.setQryprctyp(qryprctyp);
- }
-
- protected int getQryprctyp()
- throws SQLException
- {
- return currentDrdaRs.getQryprctyp();
- }
-
- protected void setQryrownbr(long qryrownbr)
- {
- currentDrdaRs.qryrownbr = qryrownbr;
- }
-
- protected long getQryrownbr()
- {
- return currentDrdaRs.qryrownbr;
- }
-
-
- protected int getQryrowset()
- {
- return currentDrdaRs.qryrowset;
- }
-
-
- protected int getBlksize()
- {
- return currentDrdaRs.blksize;
- }
-
- protected void setQryrtndta(boolean qryrtndta)
- {
- currentDrdaRs.qryrtndta = qryrtndta;
- }
-
- protected boolean getQryrtndta()
- {
- return currentDrdaRs.qryrtndta;
- }
-
-
- protected void setQryscrorn(int qryscrorn)
- {
- currentDrdaRs.qryscrorn = qryscrorn;
- }
-
- protected int getQryscrorn()
- {
- return currentDrdaRs.qryscrorn;
- }
-
- protected void setScrollType(int scrollType)
- {
- currentDrdaRs.scrollType = scrollType;
- }
-
- protected int getScrollType()
- {
- return currentDrdaRs.scrollType;
- }
-
- /**
- * is this a scrollable cursor?
- * return true if this is not a forward only cursor
- */
- protected boolean isScrollable()
- {
- return (getScrollType() != ResultSet.TYPE_FORWARD_ONLY);
- }
-
- protected void setConcurType(int scrollType)
- {
- currentDrdaRs.concurType = scrollType;
- }
-
- protected int getConcurType()
- {
- return currentDrdaRs.concurType;
- }
-
- protected void setOutovr_drdaType(int[] outovr_drdaType)
- {
- currentDrdaRs.outovr_drdaType = outovr_drdaType;
- }
-
-
- protected int[] getOutovr_drdaType()
- {
- return currentDrdaRs.outovr_drdaType;
- }
-
- protected boolean hasdata()
- {
- return currentDrdaRs.hasdata;
- }
-
- protected void setHasdata(boolean hasdata)
- {
- currentDrdaRs.hasdata = hasdata;
- }
-
- /**
- * This method is used to initialize the default statement of the database
- * for re-use. It is different from reset() method since default statements
- * get initiliazed differently. e.g: stmt variable used in default statement
- * is created only once in Database.makeConnection.
- * TODO: Need to see what exactly it means to initialize the default
- * statement. (DERBY-1002)
- *
- */
- protected void initialize()
- {
- setTypDefValues();
- }
-
-
- protected PreparedStatement explicitPrepare(String sqlStmt) throws SQLException
- {
- explicitlyPrepared = true;
- return prepare(sqlStmt);
- }
-
- protected boolean wasExplicitlyPrepared()
- {
- return explicitlyPrepared;
- }
-
- /**
- * Create a prepared statement
- *
- * @param sqlStmt - SQL statement
- *
- * @exception SQLException
- */
- protected PreparedStatement prepare(String sqlStmt) throws SQLException
- {
- // save current prepare iso level
- int saveIsolationLevel = -1;
- boolean isolationSet = false;
- if (pkgnamcsn !=null &&
- isolationLevel != Connection.TRANSACTION_NONE)
- {
- saveIsolationLevel = database.getPrepareIsolation();
- database.setPrepareIsolation(isolationLevel);
- isolationSet = true;
- }
-
- parsePkgidToFindHoldability();
-
- if (isCallableSQL(sqlStmt))
- {
- isCall = true;
- ps = database.getConnection().prepareCall(
- sqlStmt, scrollType, concurType, withHoldCursor);
- setupCallableStatementParams((CallableStatement)ps);
- }
- else
- {
- ps = database.getConnection().prepareStatement(
- sqlStmt, scrollType, concurType, withHoldCursor);
- }
-
- // beetle 3849 - Need to change the cursor name to what
- // JCC thinks it will be, since there is no way in the
- // protocol to communicate the actual cursor name. JCC keeps
- // a mapping from the client cursor names to the DB2 style cursor names
- if (cursorName != null)//cursorName not null means we are dealing with dynamic pacakges
- ps.setCursorName(cursorName);
- if (isolationSet)
- database.setPrepareIsolation(saveIsolationLevel);
+ /**Set resultSet defaults to match
+ * the statement defaults sent on EXCSQLSTT
+ * This might be overridden on OPNQRY or CNTQRY
+ **/
+
+ protected void setRsDefaultOptions(DRDAResultSet drs)
+ {
+ drs.nbrrow = nbrrow;
+ drs.qryrowset = qryrowset;
+ drs.blksize = blksize;
+ drs.maxblkext = maxblkext;
+ drs.outovropt = outovropt;
+ drs.rslsetflg = rslsetflg;
+ drs.scrollType = scrollType;
+ drs.concurType = concurType;
+ drs.setQryprctyp(qryprctyp);
+ drs.qryrowset = qryrowset;
+ }
+
+ /**
+ * Get the extData Objects
+ *
+ * @return ArrayList with extdta
+ */
+ protected ArrayList<Object> getExtDtaObjects()
+ {
+ return currentDrdaRs.getExtDtaObjects();
+ }
+
+ public void setSplitQRYDTA(byte []data)
+ {
+ currentDrdaRs.setSplitQRYDTA(data);
+ }
+ public byte[]getSplitQRYDTA()
+ {
+ return currentDrdaRs.getSplitQRYDTA();
+ }
+
+ /**
+ * Add extDtaObject
+ * @param o - object to add
+ * @param jdbcIndex - jdbc index for parameter
+ */
+ protected void addExtDtaObject (Object o, int jdbcIndex )
+ {
+ currentDrdaRs.addExtDtaObject(o,jdbcIndex);
+ }
+
+
+ /**
+ * Clear externalized lob objects in current result set
+ */
+ protected void clearExtDtaObjects ()
+ {
+ currentDrdaRs.clearExtDtaObjects();
+ }
+
+ /*
+ * Is lob object nullable
+ * @param index - offset starting with 0
+ * @return true if object is nullable
+ */
+ protected boolean isExtDtaValueNullable(int index)
+ {
+ return currentDrdaRs.isExtDtaValueNullable(index);
+ }
+
+
+ /**
+ * Set query options sent on OPNQRY and pass options down to the
+ * current <code>DRDAResultSet</code> object.
+ *
+ * @param blksize QRYBLKSZ (Query Block Size)
+ * @param qryblkctl QRYPRCTYP (Query Protocol Type)
+ * @param maxblkext MAXBLKEXT (Maximum Number of Extra Blocks)
+ * @param outovropt OUTOVROPT (Output Override Option)
+ * @param qryrowset QRYROWSET (Query Rowset Size)
+ * @param qryclsimpl QRYCLSIMP (Query Close Implicit)
+ * @see DRDAResultSet#setOPNQRYOptions(int, int, int, int, int, int)
+ */
+ protected void setOPNQRYOptions(int blksize, int qryblkctl,
+ int maxblkext, int outovropt,int qryrowset,int qryclsimpl)
+ {
+ this.blksize = blksize;
+ this.qryprctyp = qryblkctl;
+ this.maxblkext = maxblkext;
+ this.outovropt = outovropt;
+ this.qryrowset = qryrowset;
+ currentDrdaRs.setOPNQRYOptions( blksize, qryblkctl, maxblkext,
+ outovropt, qryrowset, qryclsimpl);
+ }
+
+ /*
+ * Set query options sent on CNTQRY
+ */
+ protected void setQueryOptions(int blksize, boolean qryrelscr,
+ long qryrownbr,
+ boolean qryfrtbl,int nbrrow,int maxblkext,
+ int qryscrorn, boolean qryrowsns,
+ boolean qryblkrst,
+ boolean qryrtndta,int qryrowset,
+ int rtnextdta)
+ {
+ currentDrdaRs.blksize = blksize;
+ currentDrdaRs.qryrelscr = qryrelscr;
+ currentDrdaRs.qryrownbr = qryrownbr;
+ currentDrdaRs.qryrfrtbl = qryrfrtbl;
+ currentDrdaRs.nbrrow = nbrrow;
+ currentDrdaRs.maxblkext = maxblkext;
+ currentDrdaRs.qryscrorn = qryscrorn;
+ currentDrdaRs.qryrowsns = qryrowsns;
+ currentDrdaRs.qryblkrst = qryblkrst;
+ currentDrdaRs.qryrtndta = qryrtndta;
+ currentDrdaRs.qryrowset = qryrowset;
+ currentDrdaRs.rtnextdta = rtnextdta;
+ }
+
+
+
+ protected void setQryprctyp(int qryprctyp)
+ {
+ this.qryprctyp = qryprctyp;
+ currentDrdaRs.setQryprctyp(qryprctyp);
+ }
+
+ protected int getQryprctyp()
+ throws SQLException
+ {
+ return currentDrdaRs.getQryprctyp();
+ }
+
+ protected void setQryrownbr(long qryrownbr)
+ {
+ currentDrdaRs.qryrownbr = qryrownbr;
+ }
+
+ protected long getQryrownbr()
+ {
+ return currentDrdaRs.qryrownbr;
+ }
+
+
+ protected int getQryrowset()
+ {
+ return currentDrdaRs.qryrowset;
+ }
+
+
+ protected int getBlksize()
+ {
+ return currentDrdaRs.blksize;
+ }
+
+ protected void setQryrtndta(boolean qryrtndta)
+ {
+ currentDrdaRs.qryrtndta = qryrtndta;
+ }
+
+ protected boolean getQryrtndta()
+ {
+ return currentDrdaRs.qryrtndta;
+ }
+
+
+ protected void setQryscrorn(int qryscrorn)
+ {
+ currentDrdaRs.qryscrorn = qryscrorn;
+ }
+
+ protected int getQryscrorn()
+ {
+ return currentDrdaRs.qryscrorn;
+ }
+
+ protected void setScrollType(int scrollType)
+ {
+ currentDrdaRs.scrollType = scrollType;
+ }
+
+ protected int getScrollType()
+ {
+ return currentDrdaRs.scrollType;
+ }
+
+ /**
+ * is this a scrollable cursor?
+ * return true if this is not a forward only cursor
+ */
+ protected boolean isScrollable()
+ {
+ return (getScrollType() != ResultSet.TYPE_FORWARD_ONLY);
+ }
+
+ protected void setConcurType(int scrollType)
+ {
+ currentDrdaRs.concurType = scrollType;
+ }
+
+ protected int getConcurType()
+ {
+ return currentDrdaRs.concurType;
+ }
+
+ protected void setOutovr_drdaType(int[] outovr_drdaType)
+ {
+ currentDrdaRs.outovr_drdaType = outovr_drdaType;
+ }
+
+
+ protected int[] getOutovr_drdaType()
+ {
+ return currentDrdaRs.outovr_drdaType;
+ }
+
+ protected boolean hasdata()
+ {
+ return currentDrdaRs.hasdata;
+ }
+
+ protected void setHasdata(boolean hasdata)
+ {
+ currentDrdaRs.hasdata = hasdata;
+ }
+
+ /**
+ * This method is used to initialize the default statement of the database
+ * for re-use. It is different from reset() method since default statements
+ * get initiliazed differently. e.g: stmt variable used in default statement
+ * is created only once in Database.makeConnection.
+ * TODO: Need to see what exactly it means to initialize the default
+ * statement. (DERBY-1002)
+ *
+ */
+ protected void initialize()
+ {
+ setTypDefValues();
+ }
+
+
+ protected PreparedStatement explicitPrepare(String sqlStmt) throws SQLException
+ {
+ explicitlyPrepared = true;
+ return prepare(sqlStmt);
+ }
+
+ protected boolean wasExplicitlyPrepared()
+ {
+ return explicitlyPrepared;
+ }
+
+ /**
+ * Create a prepared statement
+ *
+ * @param sqlStmt - SQL statement
+ *
+ * @exception SQLException
+ */
+ protected PreparedStatement prepare(String sqlStmt) throws SQLException
+ {
+ // save current prepare iso level
+ int saveIsolationLevel = -1;
+ boolean isolationSet = false;
+ if (pkgnamcsn !=null &&
+ isolationLevel != Connection.TRANSACTION_NONE)
+ {
+ saveIsolationLevel = database.getPrepareIsolation();
+ database.setPrepareIsolation(isolationLevel);
+ isolationSet = true;
+ }
+
+ parsePkgidToFindHoldability();
+
+ if (isCallableSQL(sqlStmt))
+ {
+ isCall = true;
+ ps = database.getConnection().prepareCall(
+ sqlStmt, scrollType, concurType, withHoldCursor);
+ setupCallableStatementParams((CallableStatement)ps);
+ }
+ else
+ {
+ ps = database.getConnection().prepareStatement(
+ sqlStmt, scrollType, concurType, withHoldCursor);
+ }
+
+ // beetle 3849 - Need to change the cursor name to what
+ // JCC thinks it will be, since there is no way in the
+ // protocol to communicate the actual cursor name. JCC keeps
+ // a mapping from the client cursor names to the DB2 style cursor names
+ if (cursorName != null)//cursorName not null means we are dealing with dynamic pacakges
+ ps.setCursorName(cursorName);
+ if (isolationSet)
+ database.setPrepareIsolation(saveIsolationLevel);
versionCounter = ((EnginePreparedStatement)ps).getVersionCounter();
return ps;
- }
+ }
- /**
- * Get prepared statement
- *
- * @return prepared statement
- */
- protected PreparedStatement getPreparedStatement() throws SQLException
- {
- return ps;
- }
-
-
- /**
- * Executes the prepared statement and populates the resultSetTable.
- * Access to the various resultSets is then possible by using
- * setCurrentDrdaResultSet(String pkgnamcsn) to set the current
- * resultSet and then calling getResultSet() or the other access
- * methods to get resultset data.
- *
- * @return true if the execution has resultSets
- */
- protected boolean execute() throws SQLException
- {
- boolean hasResultSet = ps.execute();
- // DERBY-3085 - We need to make sure we drain the streamed parameter
- // if not used by the server, for example if an update statement does not
- // update any rows, the parameter won't be used. Network Server will
- // stream only the last parameter with an EXTDTA. This is stored when the
- // parameter is set and drained now after statement execution if needed.
- try {
- drdaParamState_.drainStreamedParameter();
- } catch (IOException e) {
- throw Util.javaException(e);
- }
- // java.sql.Statement says any result sets that are opened
- // when the statement is re-executed must be closed; this
- // is handled by the call to "ps.execute()" above--but we
- // also have to reset our 'numResultSets' counter, since
- // all previously opened result sets are now invalid.
- numResultSets = 0;
-
- ResultSet rs = null;
- boolean isCallable = (ps instanceof java.sql.CallableStatement);
- if (isCallable)
- needsToSendParamData = true;
-
- do {
- rs = ps.getResultSet();
- if (rs !=null)
- {
- //For callable statement, get holdability of statement generating the result set
- if(isCallable)
- addResultSet(rs, ((EngineResultSet) rs).getHoldability());
- else
- addResultSet(rs,withHoldCursor);
- hasResultSet = true;
- }
- // For normal selects we are done, but procedures might
- // have more resultSets
- }while (isCallable && getMoreResults(Statement.KEEP_CURRENT_RESULT));
-
- return hasResultSet;
-
- }
-
- /**
- * clear out type data for parameters.
- * Unfortunately we currently overload the resultSet type info
- * rsDRDATypes et al with parameter info.
- * RESOLVE: Need to separate this
- */
+ /**
+ * Get prepared statement
+ *
+ * @return prepared statement
+ */
+ protected PreparedStatement getPreparedStatement() throws SQLException
+ {
+ return ps;
+ }
+
+
+ /**
+ * Executes the prepared statement and populates the resultSetTable.
+ * Access to the various resultSets is then possible by using
+ * setCurrentDrdaResultSet(String pkgnamcsn) to set the current
+ * resultSet and then calling getResultSet() or the other access
+ * methods to get resultset data.
+ *
+ * @return true if the execution has resultSets
+ */
+ protected boolean execute() throws SQLException
+ {
+ boolean hasResultSet = ps.execute();
+ // DERBY-3085 - We need to make sure we drain the streamed parameter
+ // if not used by the server, for example if an update statement does not
+ // update any rows, the parameter won't be used. Network Server will
+ // stream only the last parameter with an EXTDTA. This is stored when the
+ // parameter is set and drained now after statement execution if needed.
+ try {
+ drdaParamState_.drainStreamedParameter();
+ } catch (IOException e) {
+ throw Util.javaException(e);
+ }
+ // java.sql.Statement says any result sets that are opened
+ // when the statement is re-executed must be closed; this
+ // is handled by the call to "ps.execute()" above--but we
+ // also have to reset our 'numResultSets' counter, since
+ // all previously opened result sets are now invalid.
+ numResultSets = 0;
+
+ ResultSet rs = null;
+ boolean isCallable = (ps instanceof java.sql.CallableStatement);
+ if (isCallable)
+ needsToSendParamData = true;
+
+ do {
+ rs = ps.getResultSet();
+ if (rs !=null)
+ {
+ //For callable statement, get holdability of statement generating the result set
+ if(isCallable)
+ addResultSet(rs, ((EngineResultSet) rs).getHoldability());
+ else
+ addResultSet(rs,withHoldCursor);
+ hasResultSet = true;
+ }
+ // For normal selects we are done, but procedures might
+ // have more resultSets
+ }while (isCallable && getMoreResults(Statement.KEEP_CURRENT_RESULT));
+
+ return hasResultSet;
+
+ }
+
+ /**
+ * clear out type data for parameters.
+ * Unfortunately we currently overload the resultSet type info
+ * rsDRDATypes et al with parameter info.
+ * RESOLVE: Need to separate this
+ */
protected void finishParams()
- {
- needsToSendParamData = false;
- }
-
- /**
- * Set the pkgid sec num for this statement and the
- * consistency token that will be used for the first resultSet.
- * For dyamic packages The package name is encoded as follows
- * SYS(S/L)(H/N)xyy
- * where 'S' represents Small package and 'L' large
- * (ignored by Derby)
- * Where 'H' represents WITH HOLD, and 'N' represents NO WITH HOLD.
- * (May be overridden by SQLATTR for WITH
- * HOLD")
- *
- * Where 'www' is the package iteration (ignored by Derby)
- * Where 'x' is the isolation level: 0=NC, 1=UR, 2=CS, 3=RS, 4=RR
- * Where 'yy' is the package iteration 00 through FF
- * Where 'zz' is unique for each platform
- * Happilly, these values correspond precisely to the internal Derby
- * isolation levels in ExecutionContext.java
- * x Isolation Level
- * -- ---------------------
- * 0 NC (java.sql.Connection.TRANSACTION_NONE)
- * 1 UR (java.sql.Connection.TRANACTION_READ_UNCOMMITTED)
- * 2 CS (java.sql.Connection.TRANSACTION_READ_COMMITTED)
- * 3 RS (java.sql.Connection.TRANSACTION_REPEATABLE_READ)
- * 4 RR (java.sql.Connection.TRANSACTION_SERIALIZABLE)
- *
- * static packages have preset isolation levels
- * (see getStaticPackageIsolation)
- * @param pkgnamcsn package id section number and token from the client
- */
- protected void setPkgnamcsn(Pkgnamcsn pkgnamcsn)
- {
- this.pkgnamcsn = pkgnamcsn;
- // Store the consistency string for the first ResultSet.
- // this will be used to calculate consistency strings for the
- // other result sets.
- pkgid = pkgnamcsn.getPkgid();
-
- if (isDynamicPkgid(pkgid))
- {
- isolationLevel = Integer.parseInt(pkgid.substring(5,6));
-
-
- /*
- * generate DB2-style cursorname
- * example value : SQL_CURSN200C1
- * where
- * SQL_CUR is db2 cursor name prefix;
- * S - Small package , L -Large package
- * N - normal cursor, H - hold cursor
- * 200 - package id as sent by jcc
- * C - tack-on code for cursors
- * 1 - section number sent by jcc
- */
-
-
-
- // cursor name
- // trim the SYS off the pkgid so it wont' be in the cursor name
- String shortPkgid = pkgid.substring(pkgid.length() -5 , pkgid.length());
- pkgsn = pkgnamcsn.getPkgsn();
- this.cursorName = "SQL_CUR" + shortPkgid + "C" + pkgsn ;
- }
- else // static package
- {
- isolationLevel = getStaticPackageIsolation(pkgid);
- }
-
- this.pkgcnstkn = pkgnamcsn.getPkgcnstkn();
-
- }
-
-
- /**
- * get the isolation level for a static package.
- * @param pkgid - Package identifier string (e.g. SYSSTAT)
- * @return isolation
- */
- private int getStaticPackageIsolation(String pkgid)
- {
- // SYSSTAT is used for metadata. and is the only static package used
- // for JCC. Other static packages will need to be supported for
- // CCC. Maybe a static hash table would then be in order.
- if (pkgid.equals("SYSSTAT"))
- return ExecutionContext.READ_UNCOMMITTED_ISOLATION_LEVEL;
- else
- return ExecutionContext.UNSPECIFIED_ISOLATION_LEVEL;
- }
-
- /**
- * Get pkgnamcsn
- *
- * @return pkgnamcsn
- */
- protected Pkgnamcsn getPkgnamcsn()
- {
- return pkgnamcsn;
-
- }
- /**
- * Get result set
- *
- * @return result set
- */
- protected ResultSet getResultSet()
- {
- return currentDrdaRs.getResultSet();
- }
-
- /**
- * Gets the current DRDA ResultSet
- *
- * @return DRDAResultSet
- */
- protected DRDAResultSet getCurrentDrdaResultSet()
- {
- return currentDrdaRs ;
- }
-
- /**
- * Set currentDrdaResultSet
- *
- * @param rsNum The result set number starting with 0
- *
- */
- protected void setCurrentDrdaResultSet(int rsNum)
- {
- ConsistencyToken consistToken = getResultSetPkgcnstkn(rsNum);
- if (currentDrdaRs.pkgcnstkn == consistToken)
- return;
- currentDrdaRs = getDrdaResultSet(consistToken);
-
- }
-
- /**
- * Set currentDrdaResultSet
- *
- * @param pkgnamcsn The pkgid section number and unique resultset
- * consistency token
- *
- */
- protected void setCurrentDrdaResultSet(Pkgnamcsn pkgnamcsn)
- {
- pkgid = pkgnamcsn.getPkgid();
- pkgsn = pkgnamcsn.getPkgsn();
- ConsistencyToken consistToken = pkgnamcsn.getPkgcnstkn();
- DRDAResultSet newDrdaRs = getDrdaResultSet(consistToken);
- if (newDrdaRs != null)
- currentDrdaRs = newDrdaRs;
- }
-
-
- /*
- * get DRDAResultSet by consistency token
- *
- */
- private DRDAResultSet getDrdaResultSet(ConsistencyToken consistToken)
- {
- if ( resultSetTable == null ||
- (currentDrdaRs != null &&
- currentDrdaRs.pkgcnstkn == consistToken ))
- {
- return currentDrdaRs;
- }
- else
- {
- return (DRDAResultSet) (resultSetTable.get(consistToken));
- }
- }
-
- /*
- * get DRDAResultSet by result set number
- *
- */
- private DRDAResultSet getDrdaResultSet(int rsNum)
- {
- ConsistencyToken consistToken = getResultSetPkgcnstkn(rsNum);
- return getDrdaResultSet(consistToken);
- }
-
- /** Add a new resultSet to this statement.
- * Set as the current result set if there is not an
- * existing current resultset.
- * @param value - ResultSet to add
- * @param holdValue - Holdability of the ResultSet
- * @return Consistency token for this resultSet
- * For a single resultSet that is the same as the statement's
- * For multiple resultSets just the consistency token is changed
- */
- protected ConsistencyToken addResultSet(ResultSet value, int holdValue) throws SQLException
- {
-
- DRDAResultSet newDrdaRs = null;
-
- int rsNum = numResultSets;
- ConsistencyToken newRsPkgcnstkn = calculateResultSetPkgcnstkn(rsNum);
-
- if (rsNum == 0)
- newDrdaRs = currentDrdaRs;
-
- else
- {
- newDrdaRs = new DRDAResultSet();
-
- // Multiple resultSets we neeed to setup the hash table
- if (resultSetTable == null)
- {
- // If hashtable doesn't exist, create it and store resultSet 0
- // before we store our new resultSet.
- // For just a single resultSet we don't ever create the Hashtable.
- resultSetTable =
+ {
+ needsToSendParamData = false;
+ }
+
+ /**
+ * Set the pkgid sec num for this statement and the
+ * consistency token that will be used for the first resultSet.
+ * For dyamic packages The package name is encoded as follows
+ * SYS(S/L)(H/N)xyy
+ * where 'S' represents Small package and 'L' large
+ * (ignored by Derby)
+ * Where 'H' represents WITH HOLD, and 'N' represents NO WITH HOLD.
+ * (May be overridden by SQLATTR for WITH
+ * HOLD")
+ *
+ * Where 'www' is the package iteration (ignored by Derby)
+ * Where 'x' is the isolation level: 0=NC, 1=UR, 2=CS, 3=RS, 4=RR
+ * Where 'yy' is the package iteration 00 through FF
+ * Where 'zz' is unique for each platform
+ * Happilly, these values correspond precisely to the internal Derby
+ * isolation levels in ExecutionContext.java
+ * x Isolation Level
+ * -- ---------------------
+ * 0 NC (java.sql.Connection.TRANSACTION_NONE)
+ * 1 UR (java.sql.Connection.TRANACTION_READ_UNCOMMITTED)
+ * 2 CS (java.sql.Connection.TRANSACTION_READ_COMMITTED)
+ * 3 RS (java.sql.Connection.TRANSACTION_REPEATABLE_READ)
+ * 4 RR (java.sql.Connection.TRANSACTION_SERIALIZABLE)
+ *
+ * static packages have preset isolation levels
+ * (see getStaticPackageIsolation)
+ * @param pkgnamcsn package id section number and token from the client
+ */
+ protected void setPkgnamcsn(Pkgnamcsn pkgnamcsn)
+ {
+ this.pkgnamcsn = pkgnamcsn;
+ // Store the consistency string for the first ResultSet.
+ // this will be used to calculate consistency strings for the
+ // other result sets.
+ pkgid = pkgnamcsn.getPkgid();
+
+ if (isDynamicPkgid(pkgid))
+ {
+ isolationLevel = Integer.parseInt(pkgid.substring(5,6));
+
+
+ /*
+ * generate DB2-style cursorname
+ * example value : SQL_CURSN200C1
+ * where
+ * SQL_CUR is db2 cursor name prefix;
+ * S - Small package , L -Large package
+ * N - normal cursor, H - hold cursor
+ * 200 - package id as sent by jcc
+ * C - tack-on code for cursors
+ * 1 - section number sent by jcc
+ */
+
+
+
+ // cursor name
+ // trim the SYS off the pkgid so it wont' be in the cursor name
+ String shortPkgid = pkgid.substring(pkgid.length() -5 , pkgid.length());
+ pkgsn = pkgnamcsn.getPkgsn();
+ this.cursorName = "SQL_CUR" + shortPkgid + "C" + pkgsn ;
+ }
+ else // static package
+ {
+ isolationLevel = getStaticPackageIsolation(pkgid);
+ }
+
+ this.pkgcnstkn = pkgnamcsn.getPkgcnstkn();
+
+ }
+
+
+ /**
+ * get the isolation level for a static package.
+ * @param pkgid - Package identifier string (e.g. SYSSTAT)
+ * @return isolation
+ */
+ private int getStaticPackageIsolation(String pkgid)
+ {
+ // SYSSTAT is used for metadata. and is the only static package used
+ // for JCC. Other static packages will need to be supported for
+ // CCC. Maybe a static hash table would then be in order.
+ if (pkgid.equals("SYSSTAT"))
+ return ExecutionContext.READ_UNCOMMITTED_ISOLATION_LEVEL;
+ else
+ return ExecutionContext.UNSPECIFIED_ISOLATION_LEVEL;
+ }
+
+ /**
+ * Get pkgnamcsn
+ *
+ * @return pkgnamcsn
+ */
+ protected Pkgnamcsn getPkgnamcsn()
+ {
+ return pkgnamcsn;
+
+ }
+ /**
+ * Get result set
+ *
+ * @return result set
+ */
+ protected ResultSet getResultSet()
+ {
+ return currentDrdaRs.getResultSet();
+ }
+
+ /**
+ * Gets the current DRDA ResultSet
+ *
+ * @return DRDAResultSet
+ */
+ protected DRDAResultSet getCurrentDrdaResultSet()
+ {
+ return currentDrdaRs ;
+ }
+
+ /**
+ * Set currentDrdaResultSet
+ *
+ * @param rsNum The result set number starting with 0
+ *
+ */
+ protected void setCurrentDrdaResultSet(int rsNum)
+ {
+ ConsistencyToken consistToken = getResultSetPkgcnstkn(rsNum);
+ if (currentDrdaRs.pkgcnstkn == consistToken)
+ return;
+ currentDrdaRs = getDrdaResultSet(consistToken);
+
+ }
+
+ /**
+ * Set currentDrdaResultSet
+ *
+ * @param pkgnamcsn The pkgid section number and unique resultset
+ * consistency token
+ *
+ */
+ protected void setCurrentDrdaResultSet(Pkgnamcsn pkgnamcsn)
+ {
+ pkgid = pkgnamcsn.getPkgid();
+ pkgsn = pkgnamcsn.getPkgsn();
+ ConsistencyToken consistToken = pkgnamcsn.getPkgcnstkn();
+ DRDAResultSet newDrdaRs = getDrdaResultSet(consistToken);
+ if (newDrdaRs != null)
+ currentDrdaRs = newDrdaRs;
+ }
+
+
+ /*
+ * get DRDAResultSet by consistency token
+ *
+ */
+ private DRDAResultSet getDrdaResultSet(ConsistencyToken consistToken)
+ {
+ if ( resultSetTable == null ||
+ (currentDrdaRs != null &&
+ currentDrdaRs.pkgcnstkn == consistToken ))
+ {
+ return currentDrdaRs;
+ }
+ else
+ {
+ return (DRDAResultSet) (resultSetTable.get(consistToken));
+ }
+ }
+
+ /*
+ * get DRDAResultSet by result set number
+ *
+ */
+ private DRDAResultSet getDrdaResultSet(int rsNum)
+ {
+ ConsistencyToken consistToken = getResultSetPkgcnstkn(rsNum);
+ return getDrdaResultSet(consistToken);
+ }
+
+ /** Add a new resultSet to this statement.
+ * Set as the current result set if there is not an
+ * existing current resultset.
+ * @param value - ResultSet to add
+ * @param holdValue - Holdability of the ResultSet
+ * @return Consistency token for this resultSet
+ * For a single resultSet that is the same as the statement's
+ * For multiple resultSets just the consistency token is changed
+ */
+ protected ConsistencyToken addResultSet(ResultSet value, int holdValue) throws SQLException
+ {
+
+ DRDAResultSet newDrdaRs = null;
+
+ int rsNum = numResultSets;
+ ConsistencyToken newRsPkgcnstkn = calculateResultSetPkgcnstkn(rsNum);
+
+ if (rsNum == 0)
+ newDrdaRs = currentDrdaRs;
+
+ else
+ {
+ newDrdaRs = new DRDAResultSet();
+
+ // Multiple resultSets we neeed to setup the hash table
+ if (resultSetTable == null)
+ {
+ // If hashtable doesn't exist, create it and store resultSet 0
+ // before we store our new resultSet.
+ // For just a single resultSet we don't ever create the Hashtable.
+ resultSetTable =
new Hashtable<ConsistencyToken, DRDAResultSet>();
- resultSetTable.put(pkgcnstkn, currentDrdaRs);
- resultSetKeyList = new ArrayList<ConsistencyToken>();
- resultSetKeyList.add(0, pkgcnstkn);
- }
-
- resultSetTable.put(newRsPkgcnstkn, newDrdaRs);
- resultSetKeyList.add(rsNum, newRsPkgcnstkn);
- }
-
- newDrdaRs.setResultSet(value);
- newDrdaRs.setPkgcnstkn(newRsPkgcnstkn);
- newDrdaRs.withHoldCursor = holdValue;
- setRsDefaultOptions(newDrdaRs);
- newDrdaRs.suspend();
- numResultSets++;
- return newRsPkgcnstkn;
- }
-
- /**
- *
- * @return number of result sets
- */
- protected int getNumResultSets()
- {
- return numResultSets;
- }
-
-
- /**
- * @param rsNum result set starting with 0
- * @return consistency token (key) for the result set
- */
- protected ConsistencyToken getResultSetPkgcnstkn(int rsNum)
- {
- if (rsNum == 0)
- return pkgcnstkn;
- else
- return (ConsistencyToken) resultSetKeyList.get(rsNum);
- }
-
-
- /**
- *@return ResultSet DRDA DataTypes
- **/
-
- protected int[] getRsDRDATypes()
- {
- return currentDrdaRs.getRsDRDATypes();
-
- }
-
-
- /**
- * Close the current resultSet
- */
- protected void rsClose() throws SQLException
- {
- if (currentDrdaRs.getResultSet() == null)
- return;
-
- currentDrdaRs.close();
- needsToSendParamData = false;
- numResultSets--;
- }
-
- /**
- * Explicitly close the result set by CLSQRY
- * needed to check for double close.
- */
- protected void CLSQRY()
- {
- currentDrdaRs.CLSQRY();
- }
-
- /*
- * @return whether CLSQRY has been called on the
- * current result set.
- */
- protected boolean wasExplicitlyClosed()
- {
- return currentDrdaRs.wasExplicitlyClosed();
- }
-
- /**
- * This method closes the JDBC objects and frees up all references held by
- * this object.
- *
- * @throws SQLException
- */
- protected void close() throws SQLException
- {
- if (ps != null)
- ps.close();
- if (stmt != null)
- stmt.close();
- currentDrdaRs.close();
- resultSetTable = null;
- resultSetKeyList = null;
- ps = null;
- stmtPmeta = null;
- stmt = null;
+ resultSetTable.put(pkgcnstkn, currentDrdaRs);
+ resultSetKeyList = new ArrayList<ConsistencyToken>();
+ resultSetKeyList.add(0, pkgcnstkn);
+ }
+
+ resultSetTable.put(newRsPkgcnstkn, newDrdaRs);
+ resultSetKeyList.add(rsNum, newRsPkgcnstkn);
+ }
+
+ newDrdaRs.setResultSet(value);
+ newDrdaRs.setPkgcnstkn(newRsPkgcnstkn);
+ newDrdaRs.withHoldCursor = holdValue;
+ setRsDefaultOptions(newDrdaRs);
+ newDrdaRs.suspend();
+ numResultSets++;
+ return newRsPkgcnstkn;
+ }
+
+ /**
+ *
+ * @return number of result sets
+ */
+ protected int getNumResultSets()
+ {
+ return numResultSets;
+ }
+
+
+ /**
+ * @param rsNum result set starting with 0
+ * @return consistency token (key) for the result set
+ */
+ protected ConsistencyToken getResultSetPkgcnstkn(int rsNum)
+ {
+ if (rsNum == 0)
+ return pkgcnstkn;
+ else
+ return (ConsistencyToken) resultSetKeyList.get(rsNum);
+ }
+
+
+ /**
+ *@return ResultSet DRDA DataTypes
+ **/
+
+ protected int[] getRsDRDATypes()
+ {
+ return currentDrdaRs.getRsDRDATypes();
+
+ }
+
+
+ /**
+ * Close the current resultSet
+ */
+ protected void rsClose() throws SQLException
+ {
+ if (currentDrdaRs.getResultSet() == null)
+ return;
+
+ currentDrdaRs.close();
+ needsToSendParamData = false;
+ numResultSets--;
+ }
+
+ /**
+ * Explicitly close the result set by CLSQRY
+ * needed to check for double close.
+ */
+ protected void CLSQRY()
+ {
+ currentDrdaRs.CLSQRY();
+ }
+
+ /*
+ * @return whether CLSQRY has been called on the
+ * current result set.
+ */
+ protected boolean wasExplicitlyClosed()
+ {
+ return currentDrdaRs.wasExplicitlyClosed();
+ }
+
+ /**
+ * This method closes the JDBC objects and frees up all references held by
+ * this object.
+ *
+ * @throws SQLException
+ */
+ protected void close() throws SQLException
+ {
+ if (ps != null)
+ ps.close();
+ if (stmt != null)
+ stmt.close();
+ currentDrdaRs.close();
+ resultSetTable = null;
+ resultSetKeyList = null;
+ ps = null;
+ stmtPmeta = null;
+ stmt = null;
truncationWarnings = null;
- rslsetflg = null;
- procName = null;
- outputTypes = null;
- outputPrecision = null;
- outputScale = null;
- // Clear parameters and release excess storage
- drdaParamState_.clear(true);
- }
-
- /**
- * This method resets the state of this DRDAStatement object so that it can
- * be re-used. This method should reset all variables of this class except
- * the following:
+ rslsetflg = null;
+ procName = null;
+ outputTypes = null;
+ outputPrecision = null;
+ outputScale = null;
+ // Clear parameters and release excess storage
+ drdaParamState_.clear(true);
+ }
+
+ /**
+ * This method resets the state of this DRDAStatement object so that it can
+ * be re-used. This method should reset all variables of this class except
+ * the following:
* 1. database - This variable gets initialized in the constructor and by
* call to setDatabase.
* 2. members which get initialized in setPkgnamcsn (pkgnamcsn, pkgcnstkn,
* pkgid, pkgsn, isolationLevel, cursorName). pkgnamcsn is the key used to
* find if the DRDAStatement can be re-used. Hence its value will not change
* when the object is re-used.
- *
- */
- protected void reset()
- {
- setTypDefValues();
-
- withHoldCursor = -1;
- scrollType = ResultSet.TYPE_FORWARD_ONLY;
- concurType = ResultSet.CONCUR_READ_ONLY;;
- rowCount = 0;
- rslsetflg = null;
- maxrslcnt = 0;
- ps = null;
- stmtPmeta = null;
- isCall = false;
- procName = null;
- outputTypes = null;
- outputExpected = false;
- stmt = null;
+ *
+ */
+ protected void reset()
+ {
+ setTypDefValues();
+
+ withHoldCursor = -1;
+ scrollType = ResultSet.TYPE_FORWARD_ONLY;
+ concurType = ResultSet.CONCUR_READ_ONLY;;
+ rowCount = 0;
+ rslsetflg = null;
+ maxrslcnt = 0;
+ ps = null;
+ stmtPmeta = null;
+ isCall = false;
+ procName = null;
+ outputTypes = null;
+ outputExpected = false;
+ stmt = null;
truncationWarnings = null;
-
- currentDrdaRs.reset();
- resultSetTable = null;
- resultSetKeyList = null;
- numResultSets = 0;
-
- // Clear parameters without releasing storage
- drdaParamState_.clear(false);
-
- nbrrow = 0;
- qryrowset = 0;
- blksize = 0;
- maxblkext = 0;
- outovropt = 0;
- qryrfrtbl = false;
- qryprctyp = CodePoint.QRYBLKCTL_DEFAULT;
-
- needsToSendParamData = false;
- explicitlyPrepared = false;
- }
-
- /**
- * is Statement closed
- * @return whether the statement is closed
- */
- protected boolean rsIsClosed()
- {
- return currentDrdaRs.isClosed();
- }
-
- /**
- * Set state to SUSPENDED (result set is opened)
- */
- protected void rsSuspend()
- {
- currentDrdaRs.suspend();
- }
-
-
- /**
- * set resultset/out parameter precision
- *
- * @param index - starting with 1
- * @param precision
- */
- protected void setRsPrecision(int index, int precision)
- {
- currentDrdaRs.setRsPrecision(index,precision);
- }
-
- /**
- * get resultset /out paramter precision
- * @param index -starting with 1
- * @return precision of column
- */
- protected int getRsPrecision(int index)
- {
- return currentDrdaRs.getRsPrecision(index);
- }
-
- /**
- * set resultset/out parameter scale
- *
- * @param index - starting with 1
- * @param scale
- */
- protected void setRsScale(int index, int scale)
- {
- currentDrdaRs.setRsScale(index, scale);
- }
-
- /**
- * get resultset /out paramter scale
- * @param index -starting with 1
- * @return scale of column
- */
- protected int getRsScale(int index)
- {
- return currentDrdaRs.getRsScale(index);
- }
-
-
- /**
- * set result DRDAType
- *
- * @param index - starting with 1
- * @param type
- */
- protected void setRsDRDAType(int index, int type)
- {
- currentDrdaRs.setRsDRDAType(index,type);
-
- }
-
- /** Clears the parameter state (type, length and ext information)
- * stored in this statement, but does not release any
- * storage. This reduces the cost of re-executing the statement
- * since no new storage needs to be allocated. */
- protected void clearDrdaParams() {
- drdaParamState_.clear(false);
- }
-
- /** Get the number of external parameters in this
- * statement. External means parameters that are transmitted in a
- * separate DSS in the DRDA protocol.
- * @return the number of external parameters
- */
- protected int getExtPositionCount() {
- return drdaParamState_.getExtPosCount();
- }
-
- /** Get the parameter position of the i'th external parameter
- * @param i - zero-based index into list of external parameters
- * @return the parameter position of the i'th external parameter
- */
- protected int getExtPosition(int i) {
- return drdaParamState_.getExtPos(i);
- }
-
- /** Mark the pos'th parameter as external
- * @param pos - zero-based index into list of external parameters
- */
- protected void addExtPosition(int pos) {
- drdaParamState_.addExtPos(pos);
- }
-
- /** Get the number of parameters, internal and external, that has
- * been added to this statement.
- * @return the number of parameters
- */
- protected int getDrdaParamCount() {
- return drdaParamState_.getDrdaParamCount();
- }
-
- /** Add another parameter to this statement.
- * @param t - type of the parameter
- * @param l - length in bytes of the parameter
- */
- protected void addDrdaParam(byte t, int l) {
- drdaParamState_.addDrdaParam(t, l);
- }
+
+ currentDrdaRs.reset();
+ resultSetTable = null;
+ resultSetKeyList = null;
+ numResultSets = 0;
+
+ // Clear parameters without releasing storage
+ drdaParamState_.clear(false);
+
+ nbrrow = 0;
+ qryrowset = 0;
+ blksize = 0;
+ maxblkext = 0;
+ outovropt = 0;
+ qryrfrtbl = false;
+ qryprctyp = CodePoint.QRYBLKCTL_DEFAULT;
+
+ needsToSendParamData = false;
+ explicitlyPrepared = false;
+ }
+
+ /**
+ * is Statement closed
+ * @return whether the statement is closed
+ */
+ protected boolean rsIsClosed()
+ {
+ return currentDrdaRs.isClosed();
+ }
+
+ /**
+ * Set state to SUSPENDED (result set is opened)
+ */
+ protected void rsSuspend()
+ {
+ currentDrdaRs.suspend();
+ }
+
+
+ /**
+ * set resultset/out parameter precision
+ *
+ * @param index - starting with 1
+ * @param precision
+ */
+ protected void setRsPrecision(int index, int precision)
+ {
+ currentDrdaRs.setRsPrecision(index,precision);
+ }
+
+ /**
+ * get resultset /out paramter precision
+ * @param index -starting with 1
+ * @return precision of column
+ */
+ protected int getRsPrecision(int index)
+ {
+ return currentDrdaRs.getRsPrecision(index);
+ }
+
+ /**
+ * set resultset/out parameter scale
+ *
+ * @param index - starting with 1
+ * @param scale
+ */
+ protected void setRsScale(int index, int scale)
+ {
+ currentDrdaRs.setRsScale(index, scale);
+ }
+
+ /**
+ * get resultset /out paramter scale
+ * @param index -starting with 1
+ * @return scale of column
+ */
+ protected int getRsScale(int index)
+ {
+ return currentDrdaRs.getRsScale(index);
+ }
+
+
+ /**
+ * set result DRDAType
+ *
+ * @param index - starting with 1
+ * @param type
+ */
+ protected void setRsDRDAType(int index, int type)
+ {
+ currentDrdaRs.setRsDRDAType(index,type);
+
+ }
+
+ /** Clears the parameter state (type, length and ext information)
+ * stored in this statement, but does not release any
+ * storage. This reduces the cost of re-executing the statement
+ * since no new storage needs to be allocated. */
+ protected void clearDrdaParams() {
+ drdaParamState_.clear(false);
+ }
+
+ /** Get the number of external parameters in this
+ * statement. External means parameters that are transmitted in a
+ * separate DSS in the DRDA protocol.
+ * @return the number of external parameters
+ */
+ protected int getExtPositionCount() {
+ return drdaParamState_.getExtPosCount();
+ }
+
+ /** Get the parameter position of the i'th external parameter
+ * @param i - zero-based index into list of external parameters
+ * @return the parameter position of the i'th external parameter
+ */
+ protected int getExtPosition(int i) {
+ return drdaParamState_.getExtPos(i);
+ }
+
+ /** Mark the pos'th parameter as external
+ * @param pos - zero-based index into list of external parameters
+ */
+ protected void addExtPosition(int pos) {
+ drdaParamState_.addExtPos(pos);
+ }
+
+ /** Get the number of parameters, internal and external, that has
+ * been added to this statement.
+ * @return the number of parameters
+ */
+ protected int getDrdaParamCount() {
+ return drdaParamState_.getDrdaParamCount();
+ }
+
+ /** Add another parameter to this statement.
+ * @param t - type of the parameter
+ * @param l - length in bytes of the parameter
+ */
+ protected void addDrdaParam(byte t, int l) {
+ drdaParamState_.addDrdaParam(t, l);
+ }
protected void setStreamedParameter(EXTDTAReaderInputStream eis)
{
drdaParamState_.setStreamedParameter(eis);
}
- /**
- * get parameter DRDAType
- *
- * @param index - starting with 1
- * @return DRDA Type of column
- */
- protected int getParamDRDAType(int index) {
- return drdaParamState_.getDrdaType(index-1);
- }
-
- /**
- * returns drda length of parameter as sent by client.
- * @param index - starting with 1
- * @return data length
-
- */
- protected int getParamLen(int index)
- {
- return drdaParamState_.getDrdaLen(index-1);
- }
-
-
- /**
- * get parameter precision or DB2 max (31)
- *
- * @param index parameter index starting with 1
- *
- * @return precision
- */
- protected int getParamPrecision(int index) throws SQLException
- {
- if (ps != null && ps instanceof CallableStatement)
- {
- ParameterMetaData pmeta = getParameterMetaData();
-
- return Math.min(pmeta.getPrecision(index),
- FdocaConstants.NUMERIC_MAX_PRECISION);
-
- }
- else
- return -1;
- }
-
- /**
- * get parameter scale or DB2 max (31)
- *
- * @param index parameter index starting with 1
- *
- * @return scale
- */
- protected int getParamScale(int index) throws SQLException
- {
- if (ps != null && ps instanceof CallableStatement)
- {
- ParameterMetaData pmeta = getParameterMetaData();
- return Math.min(pmeta.getScale(index),FdocaConstants.NUMERIC_MAX_PRECISION);
- }
- else
- return -1;
- }
-
- /**
- * get the number of result set columns for the current resultSet
- *
- * @return number of columns
- */
-
- protected int getNumRsCols()
- {
- int[] rsDrdaTypes = getRsDRDATypes();
- if (rsDrdaTypes != null)
- return rsDrdaTypes.length;
- else
- return 0;
- }
-
- /**
- * get resultset/out parameter DRDAType
- *
- * @param index - starting with 1
- * @return DRDA Type of column
- */
- protected int getRsDRDAType(int index)
- {
- return currentDrdaRs.getRsDRDAType(index);
- }
-
- /**
- * get resultset/out parameter DRDALen
- * @param index starting with 1
- *
- * @return length of drda data
- */
-
- protected int getRsLen(int index)
- {
- return currentDrdaRs.getRsLen(index);
- }
-
- /**
- * @param rsNum - result set # starting with 0
- */
- public String getResultSetCursorName(int rsNum) throws SQLException
- {
- DRDAResultSet drdaRs = getDrdaResultSet(rsNum);
- return drdaRs.getResultSetCursorName();
-
- }
-
-
- protected String toDebugString(String indent)
- {
- String s ="";
- if (ps == null)
- s += indent + ps;
- else
- {
- s += indent + pkgid + pkgsn ;
- s += "\t" + getSQLText();
- }
- return s;
- }
-
- /** For a single result set, just echo the consistency token that the client sent us.
- * For subsequent resultSets, just subtract the resultset number from
- * the consistency token and that will differentiate the result sets.
- * This seems to be what DB2 does
- * @param rsNum - result set # starting with 0
- *
- * @return Consistency token for result set
- */
-
- protected ConsistencyToken calculateResultSetPkgcnstkn(int rsNum)
- {
- ConsistencyToken consistToken = pkgcnstkn;
-
- if (rsNum == 0 || pkgcnstkn == null)
- return consistToken;
- else
- {
- BigInteger consistTokenBi =
- new BigInteger(consistToken.getBytes());
- BigInteger rsNumBi = BigInteger.valueOf(rsNum);
- consistTokenBi = consistTokenBi.subtract(rsNumBi);
- consistToken = new ConsistencyToken(consistTokenBi.toByteArray());
- }
- return consistToken;
- }
-
- protected boolean isCallableStatement()
- {
- return isCall;
- }
-
- private boolean isCallableSQL(String sql)
- {
- java.util.StringTokenizer tokenizer = new java.util.StringTokenizer
- (sql, "\t\n\r\f=? (");
- String firstToken = tokenizer.nextToken();
- if (StringUtil.SQLEqualsIgnoreCase(firstToken,
- "call")) // captures CALL...and ?=CALL...
- return true;
- return false;
-
- }
-
- private void setupCallableStatementParams(CallableStatement cs) throws SQLException
- {
- ParameterMetaData pmeta = getParameterMetaData();
- int numElems = pmeta.getParameterCount();
-
- for ( int i = 0; i < numElems; i ++)
- {
- boolean outputFlag = false;
-
- int parameterMode = pmeta.getParameterMode(i + 1);
- int parameterType = pmeta.getParameterType(i + 1);
+ /**
+ * get parameter DRDAType
+ *
+ * @param index - starting with 1
+ * @return DRDA Type of column
+ */
+ protected int getParamDRDAType(int index) {
+ return drdaParamState_.getDrdaType(index-1);
+ }
+
+ /**
+ * returns drda length of parameter as sent by client.
+ * @param index - starting with 1
+ * @return data length
+
+ */
+ protected int getParamLen(int index)
+ {
+ return drdaParamState_.getDrdaLen(index-1);
+ }
+
+
+ /**
+ * get parameter precision or DB2 max (31)
+ *
+ * @param index parameter index starting with 1
+ *
+ * @return precision
+ */
+ protected int getParamPrecision(int index) throws SQLException
+ {
+ if (ps != null && ps instanceof CallableStatement)
+ {
+ ParameterMetaData pmeta = getParameterMetaData();
+
+ return Math.min(pmeta.getPrecision(index),
+ FdocaConstants.NUMERIC_MAX_PRECISION);
+
+ }
+ else
+ return -1;
+ }
+
+ /**
+ * get parameter scale or DB2 max (31)
+ *
+ * @param index parameter index starting with 1
+ *
+ * @return scale
+ */
+ protected int getParamScale(int index) throws SQLException
+ {
+ if (ps != null && ps instanceof CallableStatement)
+ {
+ ParameterMetaData pmeta = getParameterMetaData();
+ return Math.min(pmeta.getScale(index),FdocaConstants.NUMERIC_MAX_PRECISION);
+ }
+ else
+ return -1;
+ }
+
+ /**
+ * get the number of result set columns for the current resultSet
+ *
+ * @return number of columns
+ */
+
+ protected int getNumRsCols()
+ {
+ int[] rsDrdaTypes = getRsDRDATypes();
+ if (rsDrdaTypes != null)
+ return rsDrdaTypes.length;
+ else
+ return 0;
+ }
+
+ /**
+ * get resultset/out parameter DRDAType
+ *
+ * @param index - starting with 1
+ * @return DRDA Type of column
+ */
+ protected int getRsDRDAType(int index)
+ {
+ return currentDrdaRs.getRsDRDAType(index);
+ }
+
+ /**
+ * get resultset/out parameter DRDALen
+ * @param index starting with 1
+ *
+ * @return length of drda data
+ */
+
+ protected int getRsLen(int index)
+ {
+ return currentDrdaRs.getRsLen(index);
+ }
+
+ /**
+ * @param rsNum - result set # starting with 0
+ */
+ public String getResultSetCursorName(int rsNum) throws SQLException
+ {
+ DRDAResultSet drdaRs = getDrdaResultSet(rsNum);
+ return drdaRs.getResultSetCursorName();
+
+ }
+
+
+ protected String toDebugString(String indent)
+ {
+ String s ="";
+ if (ps == null)
+ s += indent + ps;
+ else
+ {
+ s += indent + pkgid + pkgsn ;
+ s += "\t" + getSQLText();
+ }
+ return s;
+ }
+
+ /** For a single result set, just echo the consistency token that the client sent us.
+ * For subsequent resultSets, just subtract the resultset number from
+ * the consistency token and that will differentiate the result sets.
+ * This seems to be what DB2 does
+ * @param rsNum - result set # starting with 0
+ *
+ * @return Consistency token for result set
+ */
+
+ protected ConsistencyToken calculateResultSetPkgcnstkn(int rsNum)
+ {
+ ConsistencyToken consistToken = pkgcnstkn;
+
+ if (rsNum == 0 || pkgcnstkn == null)
+ return consistToken;
+ else
+ {
+ BigInteger consistTokenBi =
+ new BigInteger(consistToken.getBytes());
+ BigInteger rsNumBi = BigInteger.valueOf(rsNum);
+ consistTokenBi = consistTokenBi.subtract(rsNumBi);
+ consistToken = new ConsistencyToken(consistTokenBi.toByteArray());
+ }
+ return consistToken;
+ }
+
+ protected boolean isCallableStatement()
+ {
+ return isCall;
+ }
+
+ private boolean isCallableSQL(String sql)
+ {
+ java.util.StringTokenizer tokenizer = new java.util.StringTokenizer
+ (sql, "\t\n\r\f=? (");
+ String firstToken = tokenizer.nextToken();
+ if (StringUtil.SQLEqualsIgnoreCase(firstToken,
+ "call")) // captures CALL...and ?=CALL...
+ return true;
+ return false;
+
+ }
+
+ private void setupCallableStatementParams(CallableStatement cs) throws SQLException
+ {
+ ParameterMetaData pmeta = getParameterMetaData();
+ int numElems = pmeta.getParameterCount();
+
+ for ( int i = 0; i < numElems; i ++)
+ {
+ boolean outputFlag = false;
+
+ int parameterMode = pmeta.getParameterMode(i + 1);
+ int parameterType = pmeta.getParameterType(i + 1);
int parameterPrecision = pmeta.getPrecision(i + 1);
int parameterScale = pmeta.getScale(i + 1);
- switch (parameterMode) {
- case JDBC30Translation.PARAMETER_MODE_IN:
- break;
- case JDBC30Translation.PARAMETER_MODE_OUT:
- case JDBC30Translation.PARAMETER_MODE_IN_OUT:
- outputFlag = true;
- break;
- case JDBC30Translation.PARAMETER_MODE_UNKNOWN:
- // It's only unknown if array
- String objectType = pmeta.getParameterClassName(i+1);
- parameterType =
- getOutputParameterTypeFromClassName(objectType);
- if (parameterType != NOT_OUTPUT_PARAM)
- outputFlag = true;
- }
-
- if (outputFlag)
- {
- if (outputTypes == null) //not initialized yet, since previously none output
- {
- outputTypes = new int[numElems];
- outputPrecision = new int [numElems];
- outputScale = new int [numElems];
- for (int j = 0; j < numElems; j++) {
- outputTypes[j] = NOT_OUTPUT_PARAM; //default init value
- outputPrecision[j] = NOT_OUTPUT_PARAM;
- outputScale[j] = NOT_OUTPUT_PARAM;
- }
- }
- // save the output type so we can register when we parse
- // the SQLDTA
- outputTypes[i] = parameterType;
- outputPrecision[i] = parameterPrecision;
- outputScale[i] = parameterScale;
- }
-
- }
- }
-
-
-
- /**
- Given an object class name get the paramameter type if the
- parameter mode is unknown.
-
- Arrays except for byte arrrays are assumed to be output parameters
- TINYINT output parameters are going to be broken because there
- is no way to differentiate them from binary input parameters.
- @param objectName Class name of object being evaluated.
- indicating if this an output parameter
- @return type from java.sql.Types
- **/
-
- protected static int getOutputParameterTypeFromClassName(String
- objectName)
- {
-
- if (objectName.endsWith("[]"))
- {
- // For byte[] we are going to assume it is input.
- // For TINYINT output params you gotta use
- // object Integer[] or use a procedure
- if (objectName.equals("byte[]"))
- {
- return NOT_OUTPUT_PARAM;
-
- //isOutParam[offset] = false;
- //return java.sql.Types.VARBINARY;
- }
-
- // Known arrays are output parameters
- // otherwise we pass it's a JAVA_OBJECT
- if (objectName.equals("java.lang.Byte[]"))
- return java.sql.Types.TINYINT;
-
- if (objectName.equals("byte[][]"))
- return java.sql.Types.VARBINARY;
- if (objectName.equals("java.lang.String[]"))
- return java.sql.Types.VARCHAR;
- if (objectName.equals("int[]") ||
- objectName.equals("java.lang.Integer[]"))
- return java.sql.Types.INTEGER;
- else if (objectName.equals("long[]")
- || objectName.equals("java.lang.Long[]"))
- return java.sql.Types.BIGINT;
- else if (objectName.equals("java.math.BigDecimal[]"))
- return java.sql.Types.NUMERIC;
- else if (objectName.equals("boolean[]") ||
- objectName.equals("java.lang.Boolean[]"))
- return java.sql.Types.BIT;
- else if (objectName.equals("short[]"))
- return java.sql.Types.SMALLINT;
- else if (objectName.equals("float[]") ||
- objectName.equals("java.lang.Float[]"))
- return java.sql.Types.REAL;
- else if (objectName.equals("double[]") ||
- objectName.equals("java.lang.Double[]"))
- return java.sql.Types.DOUBLE;
- else if (objectName.equals("java.sql.Date[]"))
- return java.sql.Types.DATE;
- else if (objectName.equals("java.sql.Time[]"))
- return java.sql.Types.TIME;
- else if (objectName.equals("java.sql.Timestamp[]"))
- return java.sql.Types.TIMESTAMP;
- }
- // Not one of the ones we know. This must be a JAVA_OBJECT
- return NOT_OUTPUT_PARAM;
- //isOutParam[offset] = false;
- //return java.sql.Types.JAVA_OBJECT;
-
- }
-
-
- public void registerAllOutParams() throws SQLException
- {
- if (isCall && (outputTypes != null))
- for (int i = 1; i <= outputTypes.length; i ++)
- registerOutParam(i);
-
- }
-
- public void registerOutParam(int paramNum) throws SQLException
- {
- CallableStatement cs;
- if (isOutputParam(paramNum))
- {
- cs = (CallableStatement) ps;
- cs.registerOutParameter(paramNum, getOutputParamType(paramNum));
- }
- }
-
- protected boolean hasOutputParams()
- {
- return (outputTypes != null);
- }
-
- /**
- * is parameter an ouput parameter
- * @param paramNum parameter number starting with 1.
- * return true if this is an output parameter.
- */
- boolean isOutputParam(int paramNum)
- {
- if (outputTypes != null)
- return (outputTypes[paramNum - 1] != NOT_OUTPUT_PARAM);
- return false;
-
- }
- /**
- * get type for output parameter.
- *
- * @param paramNum - parameter number starting with 1
- * @return jdbcType or NOT_OUTPUT_PARAM if this is not an output parameter
- */
- int getOutputParamType(int paramNum)
- {
- if (outputTypes != null)
- return (outputTypes[ paramNum - 1 ]);
- return NOT_OUTPUT_PARAM;
- }
+ switch (parameterMode) {
+ case JDBC30Translation.PARAMETER_MODE_IN:
+ break;
+ case JDBC30Translation.PARAMETER_MODE_OUT:
+ case JDBC30Translation.PARAMETER_MODE_IN_OUT:
+ outputFlag = true;
+ break;
+ case JDBC30Translation.PARAMETER_MODE_UNKNOWN:
+ // It's only unknown if array
+ String objectType = pmeta.getParameterClassName(i+1);
+ parameterType =
+ getOutputParameterTypeFromClassName(objectType);
+ if (parameterType != NOT_OUTPUT_PARAM)
+ outputFlag = true;
+ }
+
+ if (outputFlag)
+ {
+ if (outputTypes == null) //not initialized yet, since previously none output
+ {
+ outputTypes = new int[numElems];
+ outputPrecision = new int [numElems];
+ outputScale = new int [numElems];
+ for (int j = 0; j < numElems; j++) {
+ outputTypes[j] = NOT_OUTPUT_PARAM; //default init value
+ outputPrecision[j] = NOT_OUTPUT_PARAM;
+ outputScale[j] = NOT_OUTPUT_PARAM;
+ }
+ }
+ // save the output type so we can register when we parse
+ // the SQLDTA
+ outputTypes[i] = parameterType;
+ outputPrecision[i] = parameterPrecision;
+ outputScale[i] = parameterScale;
+ }
+
+ }
+ }
+
+
+
+ /**
+ Given an object class name get the paramameter type if the
+ parameter mode is unknown.
+
+ Arrays except for byte arrrays are assumed to be output parameters
+ TINYINT output parameters are going to be broken because there
+ is no way to differentiate them from binary input parameters.
+ @param objectName Class name of object being evaluated.
+ indicating if this an output parameter
+ @return type from java.sql.Types
+ **/
+
+ protected static int getOutputParameterTypeFromClassName(String
+ objectName)
+ {
+
+ if (objectName.endsWith("[]"))
+ {
+ // For byte[] we are going to assume it is input.
+ // For TINYINT output params you gotta use
+ // object Integer[] or use a procedure
+ if (objectName.equals("byte[]"))
+ {
+ return NOT_OUTPUT_PARAM;
+
+ //isOutParam[offset] = false;
+ //return java.sql.Types.VARBINARY;
+ }
+
+ // Known arrays are output parameters
+ // otherwise we pass it's a JAVA_OBJECT
+ if (objectName.equals("java.lang.Byte[]"))
+ return java.sql.Types.TINYINT;
+
+ if (objectName.equals("byte[][]"))
+ return java.sql.Types.VARBINARY;
+ if (objectName.equals("java.lang.String[]"))
+ return java.sql.Types.VARCHAR;
+ if (objectName.equals("int[]") ||
+ objectName.equals("java.lang.Integer[]"))
+ return java.sql.Types.INTEGER;
+ else if (objectName.equals("long[]")
+ || objectName.equals("java.lang.Long[]"))
+ return java.sql.Types.BIGINT;
+ else if (objectName.equals("java.math.BigDecimal[]"))
+ return java.sql.Types.NUMERIC;
+ else if (objectName.equals("boolean[]") ||
+ objectName.equals("java.lang.Boolean[]"))
+ return java.sql.Types.BIT;
+ else if (objectName.equals("short[]"))
+ return java.sql.Types.SMALLINT;
+ else if (objectName.equals("float[]") ||
+ objectName.equals("java.lang.Float[]"))
+ return java.sql.Types.REAL;
+ else if (objectName.equals("double[]") ||
+ objectName.equals("java.lang.Double[]"))
+ return java.sql.Types.DOUBLE;
+ else if (objectName.equals("java.sql.Date[]"))
+ return java.sql.Types.DATE;
+ else if (objectName.equals("java.sql.Time[]"))
+ return java.sql.Types.TIME;
+ else if (objectName.equals("java.sql.Timestamp[]"))
+ return java.sql.Types.TIMESTAMP;
+ }
+ // Not one of the ones we know. This must be a JAVA_OBJECT
+ return NOT_OUTPUT_PARAM;
+ //isOutParam[offset] = false;
[... 263 lines stripped ...]