src.com.ibm.as400.access.JDSQLStatement Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk8 Show documentation
Show all versions of jt400-jdk8 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: JDSQLStatement.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2002 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.sql.Connection; // @G4A
import java.sql.SQLException;
import java.util.StringTokenizer;
import java.util.Vector;
/**
Internal class that represents a parsed SQL statement.
This should only be used internally by the JDBC driver.
**/
//
// Implementation note:
//
// Originally, the statement was parsed as information
// was needed. For example, it did not parse to see
// if "FOR UPDATE" appeared until isForUpdate() was
// called. This strategy caused a lot of extraneous
// parsing, and most of the information is needed for
// most statements, so now all parsing is done at object
// construction time.
//
public class JDSQLStatement
{
// Native statement types.
//
static final int TYPE_UNDETERMINED = 0;
static final int TYPE_OTHER = 1;
static final int TYPE_SELECT = 2;
static final int TYPE_CALL = 3;
static final int TYPE_COMMIT = 4;
static final int TYPE_ROLLBACK = 5;
static final int TYPE_CONNECT = 6;
static final int TYPE_BLOCK_INSERT = 7;
// String constants. These will hopefully help performance
// slightly - assuming a similar optimization does not
// already take place.
private static final String AS_ = "AS";
private static final String CALL_ = "CALL";
private static final String CALL0_ = "?"; // @E1A
private static final String CALL1_ = "?=";
private static final String CALL2_ = "?=CALL";
static final String COMMA_ = ",";
private static final String CONNECT_ = "CONNECT";
private static final String CONNECTION_ = "CONNECTION"; // @F1A
static final String CROSS_ = "CROSS";
private static final String CURRENT_ = "CURRENT";
private static final String DECLARE_ = "DECLARE";
private static final String DELETE_ = "DELETE";
private static final String DISCONNECT_ = "DISCONNECT";
static final String EXCEPTION_ = "EXCEPTION";
private static final String FETCH_ = "FETCH";
private static final String FOR_ = "FOR";
private static final String FROM_ = "FROM";
static final String INNER_ = "INNER";
private static final String INSERT_ = "INSERT";
static final String JOIN_ = "JOIN";
static final String LEFT_ = "LEFT";
private static final String LPAREN_ = "(";
private static final String OF_ = "OF";
private static final String ONLY_ = "ONLY";
private static final String READ_ = "READ";
private static final String RELEASE_ = "RELEASE";
private static final String ROWS_ = "ROWS";
private static final String SELECT_ = "SELECT";
private static final String SET_ = "SET";
private static final String UPDATE_ = "UPDATE";
private static final String VALUES_ = "VALUES";
private static final String WITH_ = "WITH"; // @B3A
private static final String MERGE_ = "MERGE"; //@blksql
static final String METADATA_CALL = "CALL SYSIBM"; /*@K5A*/
private boolean canBeBatched_ = false; // @H2A
private String correlationName_ = null;
private String csProcedure_ = null; // @G4A
private String csSchema_ = null; // @G4A
private boolean hasReturnValueParameter_ = false; // @E1A
private boolean isCall_ = false;
private boolean isDeclare_ = false;
private boolean isCurrentOf_ = false;
private boolean isDRDAConnect_ = false; // @B1A
private boolean isDRDADisconnect_ = false; // @B1A
private boolean isForFetchOrReadOnly_ = false;
private boolean isForUpdate_ = false;
private boolean isImmediatelyExecutable_ = false;
boolean isInsert_ = false; // @H2C Made not private.
private boolean isSelect_ = false;
private boolean isSet_ = false; // @F4A
private boolean isSetSpecialRegister_ = false;
private boolean isSubSelect_ = false;
private boolean isPackaged_ = false;
private boolean isUpdateOrDelete_ = false;
private int nativeType_ = TYPE_OTHER;
private int numberOfParameters_;
private String selectTable_ = null;
// @C3D private StringTokenizer tokenizer_ = null;
private JDSQLTokenizer tokenizer_ = null; // @C3A
private String value_;
// private String valueForServer_ = null; // @E1A
private boolean selectTableNotSet_ = true; //@K1A boolean to determine if selectTable_ has been set, if so, then selectTableNotSet_ is false
private boolean selectFromInsert_ = false; // @GKA
private boolean isMetaDataCall_ = false; //@K5A
// Contains a list of AS400JDBCStatementListener objects to be invoked when events occur
// related to a JDSQLStatement.
private static final Vector statementListeners_ = new Vector();
// Load any statement listeners that are specified in a runtime property.
static
{
String classNames = SystemProperties.getProperty(SystemProperties.JDBC_STATEMENT_LISTENERS);
if (classNames != null)
{
StringTokenizer st = new StringTokenizer(classNames, ",");
while (st.hasMoreTokens())
{
try
{
String clazz = st.nextToken();
addStatementListener((AS400JDBCStatementListener)Class.forName(clazz).newInstance());
Trace.log(Trace.INFORMATION, "Successfully loaded JDBC statement listener "+clazz);
}
catch (Throwable t)
{
Trace.log(Trace.WARNING, "Error instantiating JDBC statement listener: ", t);
}
}
}
}
/**
* Adds an AS400JDBCStatementListener.
* @param listener
**/
public static void addStatementListener(AS400JDBCStatementListener listener)
{
if (listener != null) statementListeners_.add(listener);
}
/**
* Removes an AS400JDBCStatementListener.
* @param listener
**/
public static void removeStatementListener(AS400JDBCStatementListener listener)
{
if (listener != null) statementListeners_.remove(listener);
}
/**
Constructs a JDSQLStatement object. Use this constructor
if you know you do not need to do any conversion to native
SQL.
@param sql A SQL statement.
@exception SQLException If there is a syntax error or
a reference to an unsupported
scalar function.
**/
JDSQLStatement(String sql) throws SQLException
{
// decimalSeparator is "" because we only need it if convert is true
// this constructor is only used for SET TRANSACTION ISOLATION LEVEL called
// internally, so the last two parms can be null -- this code would need to
// be changed if this constructor were used for a CALL statement with named
// parameters
this(sql, "", false, JDProperties.PACKAGE_CRITERIA_DEFAULT, null); // @A1C //@G1C
}
/**
Constructs a JDSQLStatement object.
@param sql A SQL statement.
@param decimalSeparator The decimal separator.
@param convert Convert to native SQL?
@param packageCriteria The package criteria.
@param connection A connection object to get properties off.
@exception SQLException If there is a syntax error or
a reference to an unsupported
scalar function.
**/
JDSQLStatement(String sql, String decimalSeparator, boolean convert, String packageCriteria,
AS400JDBCConnection connection) // @A1C //@G1C
throws SQLException
{
if(sql == null)
{
JDError.throwSQLException(JDError.EXC_SYNTAX_ERROR);
}
// Ensure that the string always contains at least one
// character, since some methods depend on that fact.
if(sql.trim().length() == 0)
{
JDError.throwSQLException(JDError.EXC_SYNTAX_BLANK);
}
//@F6D // Count the number of parameters. Do not count parameter
//@F6D // markers that appear within quotes or after a comment
//@F6D // delimiter (two dashes).
//@F6D numberOfParameters_ = 0;
//@F6D int commentIndex = -1;
//@F6D int length = sql.length();
//@F6D for (int i = 0; i < length; ++i)
//@F6D {
//@F6D char ch = sql.charAt(i);
//@F6D if (ch == '\'')
//@F6D {
//@F6D while ((i < length - 1) && (sql.charAt(++i) != '\''));
//@F6D }
//@F6D else if (ch == '\"')
//@F6D {
//@F6D while ((i < length - 1) && (sql.charAt (++i) != '\"'));
//@F6D }
//@F6D else if (ch == '-')
//@F6D {
//@F6D if (i < length - 1)
//@F6D {
//@F6D if (sql.charAt(++i) == '-')
//@F6D {
//@F6D commentIndex = i;
//@F6D i = length; // break out of for loop @F2C
//@F6D }
//@F6D }
//@F6D }
//@F6D else if (ch == '?')
//@F6D {
//@F6D ++numberOfParameters_;
//@F6D }
//@F6D }
//@F6A Start new code
// Strip off comments. Don't strip comment characters in literals.
int length = sql.length();
//char[] sqlArray = sql.toCharArray();
//char[] outArray = new char[length];
// @C3D int out = -1; // We are always pre-incrementing... so start before the first char here.
// Perf Note: numberOfParameters_ will default to 0. Don't set it here.
//@G8D boolean inComment = false;
//@G7 Skip removing comments if it is a CREATE statement smaller than 32KB
//@G7 (Greater than 32KB would overflow the buffer, so we have to remove
//@G7 the comments in that case.)
//@C3D if (length > 32767 || //@G7A
//@C3D !sql.trim().toUpperCase().startsWith("CREATE")) //@G7A
//@C3D{
//@G7 If this is not a normal CREATE or the length is too big,
//@G7 we must strip out the comments!
// @C3D for (int i = 0; i < length; ++i) {
// @C3D switch (sqlArray[i]) {
// @C3D case '\'':
// @C3D outArray[++out] = sqlArray[i];
// Consume everything while looking for the ending quote character.
// @C3D while (i < length - 1) {
// @C3D outArray[++out] = sqlArray[++i];
// @C3D if (sqlArray[i] == '\'') {
// @C3D break;
// @C3D }
// @C3D }
// @C3D break;
// @C3D case '\"':
// @C3D outArray[++out] = sqlArray[i];
// Consume everything while looking for the ending quote character.
// @C3D while (i < length - 1) {
// @C3D outArray[++out] = sqlArray[++i];
// @C3D if (sqlArray[i] == '\"') {
// @C3D break;
// @C3D }
// @C3D }
// @C3D break;
// @C3D case '-':
// @C3D if (i < length - 1) {
// @C3D if (sqlArray[++i] == '-') {
// It's a single line commment (--). We are going to eat the comment until
// a new line character or the end of the string, but first output a space
// to the output buffer.
// @C3D outArray[++out] = ' ';
// @C3D while ((i < length - 1) && (sqlArray[++i] != '\n'))
// @C3D ; // do nothing but spin.
// If we didn't break the loop because we were at the end of the string...
// we broke because of a newline character. Put it into the output.
// @C3D if (i < length - 1)
// @C3D outArray[++out] = '\n';
// @C3D }
// @C3D else {
// This was not a comment. Output the characters we read.
// @C3D outArray[++out] = sqlArray[i-1];
// @C3D outArray[++out] = sqlArray[i];
// @C3D }
// @C3D }
// @C3D else {
// Last character - must write the '-'
// @C3D outArray[++out] = sqlArray[i];
// @C3D }
// @C3D break;
// @C3D case '/':
// If we are not on the last character....
// @C3D if (i < length - 1) {
// Check to see if we are starting a comment.
// @C3D if (sqlArray[++i] == '*') {
// It is a multi-line commment - write over the '/*' characters
// and set the inComment flag.
// @C3D outArray[++out] = ' ';
//@G8D inComment = true;
// @C3D int numComments = 1; //@G8A - keep track of the nesting level
//@G8C
// Need to handle nested comments.
// If we see a */, we've closed a comment block.
// If we see another /*, we've started a new block.
// @C3D while (i < length - 1 && numComments > 0) //@G8C
// @C3D {
// @C3D char cur = sqlArray[++i]; //@G8A
// @C3D if (i < length-1)
// @C3D {
// @C3D char next = sqlArray[i+1];
// @C3D if (cur == '*' && next == '/')
// @C3D {
// @C3D --numComments;
// @C3D ++i;
// @C3D }
// @C3D else if (cur == '/' && next == '*')
// @C3D {
// @C3D ++numComments;
// @C3D ++i;
// @C3D }
// @C3D }
// @C3D }
// @C3D }
// @C3D else {
// This was not a comment. Output the characters we read.
// @C3D outArray[++out] = sqlArray[i-1];
// @C3D outArray[++out] = sqlArray[i];
// @C3D }
// @C3D }
// @C3D else {
// Last character - must write the '/'
// @C3D outArray[++out] = sqlArray[i];
// @C3D }
// @C3D break;
// @C3D case '?':
// Write the character.
// @C3D outArray[++out] = sqlArray[i];
// @C3D ++numberOfParameters_;
// @C3D break;
// @C3D default:
// Write the character.
// @C3D outArray[++out] = sqlArray[i];
// @C3D break;
// @C3D }
// @C3D }
for (int i=0; i= JDUtilities.vrm540) ? 2097151 : 32767; //@PDC 2M for commentStrip in v5r4
if(length > commentStripLength)//@PDC 2M for commentStrip
{ // @C3A
String old = sql;
JDSQLTokenizer commentStripper = new JDSQLTokenizer(sql, JDSQLTokenizer.DEFAULT_DELIMITERS, true, false); // @C3A
sql = commentStripper.toString(); // @C3M
// Notify our listeners that we stripped comments.
if (old.length() != sql.length())
{
for (int i=0; i= 0)
//@F6D {
//@F6D value_ = JDEscapeClause.parse(sql.substring(0, commentIndex), decimalSeparator) + sql.substring(commentIndex);
//@F6D }
//@F6D else
//@F6D {
value_ = JDEscapeClause.parse(sql, decimalSeparator, connection.getVRM()); // @C1M
//@F6D }
}
else
{
value_ = sql;
}
value_ = AS400BidiTransform.convertSQLToHostCCSID(value_, connection); //Bidi-HCG end
tokenizer_ = new JDSQLTokenizer(value_, JDSQLTokenizer.DEFAULT_DELIMITERS, false, false); // @C3A moved this line up from below
numberOfParameters_ = tokenizer_.getNumberOfParameters(); // @C3A the tokenizer counts the number of parameter markers now
// Determine the first word.
// @F2 - We need to skip any leading parentheses and whitespace and combinations thereof.
// e.g. SELECT
// (SELECT
// ( SELECT
// ((SELECT
// ( ( SELECT
String firstWord = ""; //@F2C
// @C3D tokenizer_ = new StringTokenizer(value_);
//@KBD while(firstWord == "" && tokenizer_.hasMoreTokens()) //@F2A
while(firstWord.length() == 0 && tokenizer_.hasMoreTokens()) //@KBA
{
String word = tokenizer_.nextToken();
// Our StringTokenizer ensures that word.length() > 0
int i=0;
int len = word.length();
while(i < len && word.charAt(i) == '(')
{
++i;
}
if(i < len)
{
firstWord = word.substring(i).toUpperCase();
}
}
//@F2D if (tokenizer_.countTokens() > 0)
//@F2D { // @E2C
//@F2D firstWord = tokenizer_.nextToken().toUpperCase();
//@F2D boolean flag = true; // @E2A
//@F2D while (flag)
//@F2D { // @E2A
//@F2D if (firstWord.length() == 0) // @E2A
//@F2D {
//@F2D flag = false; // @E2A
//@F2D }
//@F2D else if (firstWord.charAt(0) == '(') // @E2A
//@F2D {
//@F2D firstWord = firstWord.substring(1); // @E2A
//@F2D }
//@F2D else // @E2A
//@F2D {
//@F2D flag = false; // @E2A
//@F2D }
//@F2D } // @E2A
//@F2D } // @E2A
//@F2D else
//@F2D {
//@F2D firstWord = "";
//@F2D }
// Handle the statement based on the first word
if((firstWord.startsWith(SELECT_)) || (firstWord.equals(WITH_)) || (firstWord.startsWith(VALUES_))) // @F5C //@VALc //@val2
{
// @B3C
isSelect_ = true;
nativeType_ = TYPE_SELECT;
}
else if((firstWord.equals(CALL_)))
{ // @E1A
isCall_ = true;
nativeType_ = TYPE_CALL;
// Check for metadata call @K5A
if (value_.indexOf(METADATA_CALL) == 0) {
isMetaDataCall_ = true;
}
if (value_.indexOf("WLM_SET_CLIENT_INFO") > 0) {
isSetSpecialRegister_ = true;
}
}
else if((firstWord.equals(CALL0_)) || (firstWord.equals(CALL1_)) || (firstWord.equals(CALL2_))) //@E1A
{
// @E1A
isCall_ = true; // @E1A
nativeType_ = TYPE_CALL; // @E1A
hasReturnValueParameter_ = true; // @E1A
--numberOfParameters_; // We will "fake" the first one. // @E1A
} // @E1A
// @E10 moved Release to its own block
else if(firstWord.equals(CONNECT_) || firstWord.equals(CONNECTION_) || firstWord.equals(DISCONNECT_)) //@F1C @E10c
{
nativeType_ = TYPE_CONNECT;
if(firstWord.equals(CONNECT_)) // @B1A
{
isDRDAConnect_ = true; // @B1A
}
else if(firstWord.equals(DISCONNECT_)) // @B1A
{
isDRDADisconnect_ = true; // @B1A
}
}
// @E10 now release can be both a DRDC connection release or a savepoint release
else if(firstWord.equals(RELEASE_)) //@E10a
{
//@E10a
String upperCaseSql = value_.toUpperCase(); //@E10a
int k = upperCaseSql.indexOf("SAVEPOINT"); //@E10a
if(k >= 0) //@E10a
{
} // no need to do anything //@E10a
else //@E10a
nativeType_ = TYPE_CONNECT; //@E10a
} //@E10a
else if(firstWord.equals(INSERT_))
{
isInsert_ = true;
// Look for the string ROWS VALUES in the string.
String upperCaseSql = value_.toUpperCase();
int k = upperCaseSql.indexOf(ROWS_);
int len = upperCaseSql.length(); //@F2A @H2M
if(k != -1)
{
k += 4;
while(k < len && Character.isWhitespace(upperCaseSql.charAt(k))) //@F2C
{
++k;
}
if(upperCaseSql.regionMatches(k, VALUES_, 0, 6))
{
nativeType_ = TYPE_BLOCK_INSERT;
}
}
//@H2A Look for VALUES clause to determine whether this statement can be block inserted.
//@H2A The database will throw out block insert statements that have values other than
//@H2A parameter markers, like "INSERT INTO TABLE VALUES (NULL, ?)".
int m = upperCaseSql.indexOf(VALUES_); //@H2A
if(m != -1) //@H2A
{
//@H2A
m += 6; //@H2A
while(m < len && Character.isWhitespace(upperCaseSql.charAt(m))) //@H2A
{
//@H2A
++m; //@H2A
} //@H2A
//@H2A
int lastParen = upperCaseSql.lastIndexOf(")"); //@H2A
//@J1 - According to the DB2 SQL Reference, paranthesis are optional around a single value
//@J1D if(lastParen < m)
//@J1D {
//@J1D JDError.throwSQLException(this, JDError.EXC_SYNTAX_ERROR);
//@J1D }
if(lastParen >= 1 && lastParen > m) //@J1A make sure last parenthesis is after the VALUES keyword
{ //@J1A
String valuesString = upperCaseSql.substring(m+1, lastParen); //@H2A
StringTokenizer tokenizer = new StringTokenizer (valuesString, ", ?\n\r\t"); //@H2A
if(!tokenizer.hasMoreTokens()) //@H2A
{
//@H2A
canBeBatched_ = true; //@H2A
} //@H2A
} //@J1A
else //@J1A Check to see if only one value or one parameter marker exists, if more than one value, then it is a syntax error
{ //@J1A
String valuesString = upperCaseSql.substring(m); //@J1A - get everything after the VALUES clause
if(valuesString.trim().equals("?")) //@J1A - there is only one parameter marker, therefore, we can batch
canBeBatched_ = true; //@J1A
else //@J1A - make sure there is only one literal, otherwise a syntax error occured.
{ //@J1A
// @A1D
// If a syntax error can occur, leave it to the engine to throw the exception.
// This code to throw an exception was removed because after V6R1 the syntax
// "insert into x values 1,2,3" is valid
//StringTokenizer tokenizer = new StringTokenizer(valuesString, ","); //@J1A
//if(tokenizer.countTokens() > 1) //@J1A
// JDError.throwSQLException(this, JDError.EXC_SYNTAX_ERROR); //@J1A
} //@J1A
} //@J1A
}
}
else if((firstWord.equals(UPDATE_)) || (firstWord.equals(DELETE_)))
{
if(connection.getVRM() >= JDUtilities.vrm710) { //@blksql
if (((AS400JDBCConnection)connection).doUpdateDeleteBlocking()) {
canBeBatched_ = true; //@blksql
}
}
isUpdateOrDelete_ = true;
}
else if(firstWord.equals(MERGE_)) //@blksql
{
if((connection).getVRM() >= JDUtilities.vrm710) { //@blksql
canBeBatched_ = true; //@blksql
}
}
else if(firstWord.equals(DECLARE_))
{
isDeclare_ = true;
}
else if(firstWord.equals(SET_)) // @F4A - This entire block.
{
isSet_ = true;
nativeType_ = TYPE_UNDETERMINED;
// Note: See loop below for SET CONNECTION.
}
//@G4A New code starts
if(isCall_)
{
// Strip off extra '?'s or '='s
while(tokenizer_.hasMoreTokens() && !firstWord.endsWith(CALL_))
{
firstWord = tokenizer_.nextToken ().toUpperCase ();
}
String token = tokenizer_.nextToken();
int index = token.indexOf('(');
// Strip off the beginning of the parameters.
if(index != -1)
token = token.substring(0, index);
String namingSeparator;
if((connection).getProperties().
getString(JDProperties.NAMING).equalsIgnoreCase("sql"))
{
namingSeparator = ".";
}
else {
namingSeparator = "/";
}
//@DELIMa Added the following block to handle case sensitive procedure names and collection names
String qualifiedProcedure = null; // + procedure
StringBuffer buf = null; // for appending additional tokens
int schemaDelimEndIndex = -1; //@PDA flag used to preserve index inside qualifiedProcedure if schema is delim
// If no quotes, and there's a separator in the middle, no need to peekToken().
int separatorPos = token.indexOf(namingSeparator);
if(token.indexOf('\"') == -1 && separatorPos > 0 && separatorPos < token.length()-1)
{
qualifiedProcedure = token;
}
else if(token.endsWith(namingSeparator)) // schema not quoted, procedure is quoted
{
if(tokenizer_.hasMoreTokens()) {
buf = new StringBuffer(token);
buf.append(tokenizer_.nextToken());
}
}
else if(tokenizer_.hasMoreTokens() && tokenizer_.peekToken().equals(namingSeparator)) // both schema and procedure are quoted
{
schemaDelimEndIndex = token.length();
buf = new StringBuffer(token);
buf.append(tokenizer_.nextToken());
if(tokenizer_.hasMoreTokens()) {
buf.append(tokenizer_.nextToken());
}
}
else if(tokenizer_.hasMoreTokens() && tokenizer_.peekToken().startsWith(namingSeparator)) // schema is quoted (and maybe procedure too)
{
schemaDelimEndIndex = token.length();
buf = new StringBuffer(token);
buf.append(tokenizer_.nextToken());
}
else
{
qualifiedProcedure = token; // neither schema nor procedure is quoted
}
if(buf != null)
{
qualifiedProcedure = buf.toString();
int parenPos = qualifiedProcedure.indexOf('(');
// Strip off the beginning of the parameters.
if(parenPos != -1)
qualifiedProcedure = qualifiedProcedure.substring(0, parenPos);
}
buf = null; // we're done with the buffer
// @PDC preserve index if schema is quoted, since it may contain a namingSeparator (ie. "De.lim"."My.Proc" )
if(schemaDelimEndIndex == -1)
{
index = qualifiedProcedure.indexOf(namingSeparator);
} else
{
index = schemaDelimEndIndex;
}
if(index == -1)
{
csProcedure_ = JDUtilities.upperCaseIfNotQuoted(qualifiedProcedure);
// Currently don't handle correctly if more than one library in list.
csSchema_ = "";
}
else
{
csProcedure_ = JDUtilities.upperCaseIfNotQuoted(qualifiedProcedure.substring(index+1));
csSchema_ = JDUtilities.upperCaseIfNotQuoted(qualifiedProcedure.substring(0,index));
}
}
//@G4A New code ends
// Now we need to do some parsing based on the
// rest of the words. These are tests for the
// following certain phrases:
//
// CURRENT OF
// FOR FETCH ONLY
// FOR READ ONLY
// FOR UPDATE
// FROM (select from-clause)
//
boolean isSecondToken = true; // @F4A
while(tokenizer_.hasMoreTokens())
{
String token = tokenizer_.nextToken().toUpperCase();
if(isInsert_ && token.equals(SELECT_))
{
isSubSelect_ = true;
}
else if(token.equals(CURRENT_) && tokenizer_.hasMoreTokens() &&
tokenizer_.nextToken().equalsIgnoreCase(OF_))
{
isCurrentOf_ = true;
}
else if(token.equals(FOR_))
{
parseFor();
}
else if(isSelect_ && token.equals(FROM_) && selectTableNotSet_) //@K1C Added not set to check for subqueries
{
selectTableNotSet_ = false; //@K1A
if(tokenizer_.hasMoreTokens())
{
token = tokenizer_.nextToken(); //@F3C
if(!token.startsWith(LPAREN_))
{
// The "@G6A" code is trying to fix our parsing of the
// table-name in statements like
// SELECT * FROM collection."table with space" WHERE ....
// The tokenizer will break this up into tokens
// SELECT
// *
// FROM
// collection."table
// with
// space
// A customer reported a bug where we incorrectly re-formed
// the table name when doing an update row. The string we
// ended up with was.
// UPDATE collection."table SET column = value WHERE CURRENT OF cursor
// Note the fix is not to just slam tokens together, separating them by a space,
// until we find a token that ends with a quote. That won't fix the case
// where multiple spaces are between characters such as collection."a b".
// "a b" and "a b" are different tables. The fix is to go back to the
// original SQL statement, find the beginning of the collection/table name,
// then copy characters until finding the ending quote.
//if (token.indexOf('\"') >= 0) //@G6A
//{ //@G6A
// // find out if we already have the whole name by counting the quotes //@G6A
// int cnt = 0; //@G6A
// int ind = -1; //@G6A
// while ((ind = token.indexOf('\"', ind+1)) >= 0) { //@G6A
// cnt++; //@G6A
// } //@G6A
// // if there is an even number of quotes we already have an open //@G6A
// // and close so there is no need to look for another close //@G6A
// if (cnt % 2 == 0) { //@G6A
// selectTable_ = token; //@G6A
// } else { //@G6A
// // grab the rest of the token to the closing quote //@G6A
// String quotetok = ""; //@G6A
// if (tokenizer_.hasMoreTokens()) { //@G6A
// quotetok = tokenizer_.nextToken("\"") + "\""; //@G6A
// // grab the quote token from the end //@G6A
// tokenizer_.nextToken(" \t\n\r\f"); //@G6A
// } //@G6A
// selectTable_ = token + quotetok; //@G6A
// } //@G6A
//} //@G6A
//else //@G6A
// @C3A put the code to determine the naming separator down here too
String namingSeparator;
if((connection).getProperties().
getString(JDProperties.NAMING).equalsIgnoreCase("sql"))
{
namingSeparator = ".";
}
else
namingSeparator = "/";
// @C3A added the following block to handle case sensitive table and collection names
if(token.endsWith(namingSeparator))
{
StringBuffer table = new StringBuffer(token);
if(tokenizer_.hasMoreTokens())
table.append(tokenizer_.nextToken());
selectTable_ = table.toString();
}
else if(tokenizer_.hasMoreTokens() && tokenizer_.peekToken().equals(namingSeparator))
{
StringBuffer table = new StringBuffer(token);
table.append(tokenizer_.nextToken());
if(tokenizer_.hasMoreTokens())
table.append(tokenizer_.nextToken());
selectTable_ = table.toString();
}
else if(tokenizer_.hasMoreTokens() && tokenizer_.peekToken().startsWith(namingSeparator))
{
StringBuffer table = new StringBuffer(token);
table.append(tokenizer_.nextToken());
selectTable_ = table.toString();
}
else
{
selectTable_ = token; //@G6M
}
// @C3A end case sensitive table and collection name block
// If common table expressions are used, then sometimes the selectTable_ will end with a ).
// Go ahead and remove it. @WAA
int stLen = selectTable_.length();
if (selectTable_.charAt(stLen-1) == ')') {
selectTable_ = selectTable_.substring(0, stLen-1);
}
if(tokenizer_.hasMoreTokens())
{
token = tokenizer_.nextToken().toUpperCase();
if(token.equals(AS_) && tokenizer_.hasMoreTokens())
{
correlationName_ = tokenizer_.nextToken().toUpperCase();
}
else if(token.equals(FOR_))
{
parseFor();
}
}
}
}
}
else if(isSet_ && isSecondToken && token.equals(CONNECTION_)) // @F4A - This entire block.
{
nativeType_ = TYPE_CONNECT;
} else if (isSet_ && isSecondToken) {
if (token.equals(CURRENT_) ||
(token.equals("PATH")) ||
(token.equals("SESSION")) ||
(token.equals("SCHEMA")) ||
(token.equals("CURRENT_SCHEMA")) ||
(token.equals("COLLECTION"))) {
isSetSpecialRegister_ = true;
}
}
isSecondToken = false; // @F4A
}
// Based on all of the information that we
// have gathered up to this point, determine
// a few more tidbits.
boolean intermediate = (numberOfParameters_ > 0)
|| (isInsert_ && isSubSelect_)
|| (isCurrentOf_ && isUpdateOrDelete_);
isImmediatelyExecutable_ = ! (intermediate || isSelect_);
// @F8a Update package caching criteria to match ODBC and what is stated in
// @F8a our properties page.
// @F8a
// @F8d // @A1C
// @F8d // Changed the logic to determine isPackaged_ from the
// @F8d // "package criteria" property.
// @F8d if (packageCriteria.equalsIgnoreCase(JDProperties.PACKAGE_CRITERIA_DEFAULT))
// @F8d { // @A1A
// @F8d isPackaged_ = intermediate
// @F8d || (isSelect_ && ! isForFetchOrReadOnly_)
// @F8d || (isDeclare_);
// @F8d } // @A1A
// @F8d else
// @F8d { // @A1A
// @F8d isPackaged_ = (isInsert_ && isSubSelect_) // @A1A
// @F8d || (isCurrentOf_ && isUpdateOrDelete_) // @A1A
// @F8d || (isSelect_ && ! isForFetchOrReadOnly_) // @A1A
// @F8d || (isDeclare_); // @A1A
// @F8d } // @A1A
// 2011-11-29. If the statement has parameters, let it be stored in the package
// even if a update or delete.
isPackaged_ = ((numberOfParameters_ > 0) && !isCurrentOf_ ) // @F8a
|| (isInsert_ && isSubSelect_) // @F8a
|| (isSelect_ && isForUpdate_) // @F8a
|| (isDeclare_); // @F8a
// @F8a
if(packageCriteria.equalsIgnoreCase(JDProperties.PACKAGE_CRITERIA_SELECT)) // @F8a
{
// @F8a
isPackaged_ = isPackaged_ || isSelect_; // @F8a
} // @F8a
// If there is a return value parameter, strip if off now. @E1A
// The database does not understand these. @E1A
if(hasReturnValueParameter_)
{ // @E1A
int call = value_.toUpperCase().indexOf(CALL_); // @E1A
if(call != -1) // @E1A
{
value_ = value_.substring(call); // @E1A
}
} // @E1A
// Trim once and for all. @E1A
value_ = value_.trim(); // @E1A
tokenizer_ = null; //@mem make avail for GC now
}
//@H2A
/**
Indicates if the statement can be batched.
@return true if the statement can be batched;
false otherwise.
**/
boolean canBatch()
{
return canBeBatched_;
}
/**
Returns the number of parameters in the SQL statement.
@return Number of parameters.
**/
int countParameters()
{
return numberOfParameters_;
}
/**
Returns the correlation name for a SELECT statement.
@return The correlation name, or null if no correlation name
is specified, or this is not a SELECT statement.
**/
String getCorrelationName()
{
return correlationName_;
}
/**
Returns the native statement type.
@return Native type.
**/
int getNativeType()
{
return nativeType_;
}
//@G4A
/**
Returns the number of parameters for a statement.
@return The number of parameters parsed in this class, or 0
if no parameters were parsed.
**/
int getNumOfParameters()
{
return numberOfParameters_;
}
//@G4A
/**
Returns the procedure name name for a CALL stored procedure statement.
@return The procedure name, or null if no stored procedure name
is specified, or this is not a CALL statement.
**/
String getProcedure()
{
return csProcedure_;
}
//@G4A
/**
Returns the schema name for a CALL stored procedure statement.
@return The schema name, or null if no stored procedure name
is specified, or this is not a CALL statement.
**/
String getSchema()
{
return csSchema_;
}
/**
Returns the single table name for a SELECT statement.
@return The single table name, or null if multiple tables
were specified, or this is not a SELECT statement.
**/
String getSelectTable()
{
return selectTable_;
}
// @E1A
/**
Indicates if the SQL statement has a return value parameter.
@return true if the SQL statement has a return value parameter,
false otherwise.
**/
boolean hasReturnValueParameter() // @E1A
{ // @E1A
return hasReturnValueParameter_; // @E1A
} // @E1A
// @B1A
/**
Indicates if the statement initiates a
DRDA connection.
@return true if the statement initiates a
DRDA connection; false otherwise.
**/
boolean isDRDAConnect()
{
return isDRDAConnect_;
}
// @B1A
/**
Indicates if the statement closes a
DRDA connection.
@return true if the statement closes a
DRDA connection; false otherwise.
**/
boolean isDRDADisconnect()
{
return isDRDADisconnect_;
}
/**
Indicates if the statement contains a FOR FETCH
ONLY or FOR READ ONLY clause.
@return true if the statement contains a
FOR FETCH ONLY or FOR READ ONLY clause;
false otherwise.
**/
boolean isForFetchOnly()
{
return isForFetchOrReadOnly_;
}
/**
Indicates if the statement contains a FOR UPDATE
clause.
@return true if the statement contains a
FOR UPDATE clause; false otherwise.
**/
boolean isForUpdate()
{
return isForUpdate_;
}
/**
Indicates if the statement can be executed immediately
without doing a separate prepare and execute.
@return true if the statement can be executed
immediately executable; false otherwise.
**/
boolean isImmediatelyExecutable()
{
return isImmediatelyExecutable_;
}
/**
Indicates if this statement should be stored in
a package. This decision is based on characteristics
that make statements good candidates for being
stored in packages (those that will likely benefit
overall performance by being stored in a package).
This helps to reduce clutter in packages.
@return true if the statement should be stored
in a package; false otherwise.
**/
boolean isPackaged()
{
return isPackaged_;
}
/**
Indicates if the statement is a stored procedure call.
@return true if the statement is a stored
procedure call; false otherwise.
**/
boolean isProcedureCall()
{
return isCall_;
}
/**
Indicates if the statement a SELECT.
@return true if the statement is a SELECT;
false otherwise.
**/
boolean isSelect()
{
return isSelect_;
}
/**
Parses the token after FOR.
**/
private void parseFor()
{
if(tokenizer_.hasMoreTokens())
{
String token = tokenizer_.nextToken().toUpperCase();
if((token.equals(FETCH_)) || (token.equals(READ_)))
{
if(tokenizer_.hasMoreTokens() && tokenizer_.nextToken().equalsIgnoreCase(ONLY_))
{
isForFetchOrReadOnly_ = true;
}
}
else if(token.equals(UPDATE_))
{
isForUpdate_ = true;
}
}
}
// @G5 new method
/**
Sets the native statement type to one of the valid types.
If an invalid type is specified, no change will occur.
Valid types are:
- TYPE_UNDETERMINED
- TYPE_OTHER
- TYPE_UNDETERMINED
- TYPE_OTHER
- TYPE_SELECT
- TYPE_CALL
- TYPE_COMMIT
- TYPE_ROLLBACK
- TYPE_CONNECT
- TYPE_BLOCK_INSERT
@param type Native statement type.
**/
public void setNativeType (int type) // @G5A
{ // @G5A
nativeType_ = type; // @G5A
return; // @G5A
} // @G5A
// @GKA
public void setSelectFromInsert(boolean selectFromInsert){
selectFromInsert_ = selectFromInsert;
}
// @GKA
public boolean isSelectFromInsert()
{
return selectFromInsert_;
}
/**
Returns the SQL statement as a String. This will be
native SQL if conversion was requested.
@return The string, optionally native SQL.
**/
public String toString()
{
return value_; // @E1C
}
boolean getIsMetaDataCall() {
return isMetaDataCall_;
} /*@K5A*/
public boolean isSetSpecialRegister() {
return isSetSpecialRegister_;
}
}