BNF for sqlgrammar.jj

NON-TERMINALS

/*
 * Statement
 */

/*
 * StatementPart
 * 
 * @param tokenHolder returns the token that starts
 * the statement.  If null, ignored.
 */

/*
 * spsCreateStatement
 */

/*
 * spsDropStatement
 */

/*
 * spsAlterStatement
 */

/*
 * spsSetStatement
 */

/*
 * preparableSQLDataStatement
 *
 * preparableSQLDataStatement differs from
 * directSQLDataStatement in that it
 * supports positioned update and delete
 * and a preparable select (with FOR UPDATE)
 * instead of a direct select (without FOR UPDATE)
 */

/*
 * preparableDeleteStatement
 *
 *	This may be a search or positioned delete statement.
 */

/*
 * currentOfClause
 */

/*
 * preparableSelectStatement
 *
 *
 *	The preparable select statement is a superset of
 *	the directSelectStatementMultipleRows in that it
 *	allows both the preparable single row select statement
 *	(a query expression that returns one row, although it
 *	is also handled like a cursor) and the preparable
 *	multiple row select statement, which allows not only
 *	an order by clause but also a for update clause.
 */

/*
 * insertStatement
 */

/*
 * preparableUpdateStatement
 */

/*
 * callStatement
 */

/*
 * baseCallStatement
 */

/*
 * primaryExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/* 
 * savepointStatement

	savepointStatementClauses contains the UNIQUE, ON ROLLBACK RETAIN LOCKS, ON ROLLBACK RETAIN CURSORS clauses.

	0 - Boolean - UNIQUE clause
	1 - Boolean - ON ROLLBACK RETAIN LOCKS clause
	2 - Boolean - ON ROLLBACK RETAIN CURSORS clause
 */

/*
 * LocksOrCursors
 */

/* 
 * globalTemporaryTableDeclaration

	declareTableClauses contains the NOT LOGGED, on commit and on rollback clauses.

	0 - Boolean - NOT LOGGED clause
	1 - Boolean - on commit behavior
	2 - Boolean - on rollback behavior
 */

/*
 * onCommit
 */

/*
 * tableElementList
 */

/*
 * tableElement
 */

/*
 * columnDefinition
 */

/*
 * defaultAndConstraints
 */

/*
 * dataTypeDDL
 */

/*
 * dataTypeCast
 */

/*
 * dataTypeCommon
 */

/*
 * characterStringType
 */

/*
 * charOrCharacter
 */

/*
 * charType
 */

/*
** forBitData
*/

/*
 * nationalCharacterStringType
 */

/*
 * lobType
 */

/*
 * numericType
 */

/*
 * exactNumericType
 */

/*
 * exactNumericType
 */

/*
 * approximateNumericType
 */

/*
 * doubleType
 */

/*
 * longType
 */

/*
 * XMLType
 */

/*
 * xmlDocOrContent
 *
 * Parse the XML keywords DOCUMENT and CONTENT.  We don't
 * support CONTENT yet, so we throw an appropriate error
 * if we see it.
 *
 */

/*
 * javaType
 */

/*
 * javaDSL
 *
 * A Java dot-separated list.
 */

/*
 * javaClassName
 */

/*
 * javaDSLNameExtender
 */

/*
 * lengthAndModifier
 */

/*
 * length
 */

/*
 * exactNumber
*/

/*
 * precision
 */

/*
 * uint_value
 */

/*
 * scale
 */

/*
 * datetimeType
 */

/*
 * timePrecision
 */

/*
 * qualifiedName
 */

/*
 * queryExpression
 *
 * We have to be carefull to get the associativity correct. According to the SQL spec
 *    ::=
 *     
 *    |  UNION [ ALL ] 
 *    |  EXCEPT [ ALL ] 
 * Meaning that
 *   t1 UNION ALL t2 UNION t3
 * is equivalent to
 *   (t1 UNION ALL t2) UNION t3
 * However recursive descent parsers want recursion to be on the right, so this kind of associativity is unnatural
 * for our parser. The queryExpression method must know whether it is being called as the right hand side of a
 * set operator to produce a query tree with the correct associativity.
 */

/*
 * unionOrExcept
 */

/*
 * nonJoinQueryTerm
 *
 * Be careful with the associativity of INTERSECT. According to the SQL spec
 *   t1 INTERSECT t2 INTERSECT ALL t3
 * is equivalent to
 *   (t1 INTERSECT t2) INTERSECT ALL t3
 * which is not the same as
 *   t1 INTERSECT (t2 INTERSECT ALL t3)
 * See the comment on queryExpression.
 */

/*
 * intersect
 */

/*
 * nonJoinQueryPrimary
 */

/*
 * simpleTable
 */

/*
 * querySpecification
 */

/*
 * setQuantifier
 */

/*
 * selectList
 */

/*
 * selectSublist
 */

/*
 * derivedColumn
 */

/*
 * asClause
 */

/*
 * valueExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * orExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * andExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * isSearchCondition
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * booleanPrimary
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * predicate
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * remainingPredicates
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * remainingNonNegatablePredicate
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * remainingNegatablePredicate
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * compOp
 */

/*
 * additiveExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * additiveOperator
 */

/*
 * multiplicativeExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * multiplicativeOperator
 */

/*
 * unaryExpression
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * sign
 */

/*
 * primaryExpressionXX
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * nonStaticMethodInvocation
 */

/*
 * methodName
 */

/*
 * staticMethodName
 */

/*
 * methodParameter
 */

/*
 * primary
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * staticClassReference
 */

/*
 * staticClassReferenceType
 */

/*
 * staticClassFieldReference
 */

/*
 * nonSecondDatetimeField
 */

/*
 * timestampArithmeticFuncion
 */

/*
 * jdbcIntervalType
 */

/*
 * numericValueFunction
 */

/*
 * coalesceFunction
 */

/*
 * coalesceExpression
 */

/*
 * absFunction
 */

/*
 * modFunction
 */

/*
 * datetimeField
 */

/*
 * valueExpressionPrimary
 * 
 * @param inSelectClause will be true if this method got called while parsing the select or values clause
 * If in select or values clause, we do not want to allow boolean values.
 */

/*
 * miscBuiltins
 */

/*
 * dataTypeScalarFunction
 */

/*
 * xmlFunction
 *
 * This method parses the built-in functions used with
 * the XML datatype.
 *
 */

/*
 * xmlParseValue
 *
 * Syntax is as follows:
 *
 *     XMLPARSE( DOCUMENT  PRESERVE WHITESPACE )
 *
 * The result of this operation will be an XML value, which can either
 * be used transiently or else can be stored persistently in a table that
 * has an XML column.  For example:
 *
 * ij> CREATE TABLE x_table (id INT, xdoc XML);
 * 0 rows inserted/updated/deleted
 * ij> INSERT INTO x_table VALUES (1, XMLPARSE(DOCUMENT ' doc '
 * PRESERVE WHITESPACE));
 * 1 row inserted/updated/deleted
 *
 * We only allow XML documents (as opposed to XML content) to be
 * parsed into XML values.  Note that we require the "PRESERVE WHITESPACE"
 * keyword to be explicit; this is because the SQL/XML (2003) spec says that
 * if no whitespace option is given, the default is "STRIP WHITESPACE", which
 * we don't support (yet).
 *
 * By the time we get to this method, the "DOCUMENT" keyword has already
 * been parsed.
 *
 */

/*
 * xmlPreserveWhitespace
 *
 * For now, we only support the PRESERVE WHITESPACE option.
 *
 */

/*
 * xmlSerializeValue
 *
 * Syntax is as follows:
 *
 *   XMLSERIALIZE(  AS  )
 *
 * The result of this operation will be a string value with the type specified
 * by the user.  For example:
 *
 * ij> SELECT id, XMLSERIALIZE(xdoc AS varchar(30)) FROM x_table;
 * ID         |2
 * ------------------------------------------
 * 1          | doc 
 *
 */

/*
 * xmlSerializeTargetType
 *
 * Parse the target type of an XMLSERIALIZE operation.
 *
 */

/*
 * xmlExistsValue
 *
 * Syntax is as follows:
 *
 *   XMLEXISTS(  PASSING BY VALUE  )
 *
 * The result of this operation will be a boolean true/false/unknown value:
 *   -- Unknown if either  or  is null;
 *   -- True if at least one node in the given xml-value matches the given
 *      XPath expression;
 *   -- False otherwise.
 *
 * For example:
 *
 * ij> SELECT id FROM x_table WHERE XMLEXISTS('/simple' PASSING BY VALUE xdoc);
 * ID
 * -----------
 * 1
 *
 */

/*
 * xmlPassingMechanism
 *
 * For now, we only support the BY VALUE option because,
 * at query time, we take the XML string value from disk and
 * pass it into Xalan, which creates a "copy" of the XML
 * value internally (as DOM/DTM) and then executes against
 * that.  Because Xalan creates this copy, this impl
 * is BY VALUE.
 *
 */

/*
 * numericFunctionType
 */

/*
 * dateTimeScalarFunction
 */

/*
 * timestampFunctionCompletion
 */

/*
 * booleanLiteral
 */

/*
 * generalValueSpecification
 */

/*
 * newInvocation
 */

/*
 * staticMethodInvocation
 */

/**
 * methodCallParameterList
*/

/*
 * routineInvocation
 */

/*
 * javaClass
 */

/*
 * columnMethodInvocation
 */

/*
 * columnNameForInvocation
 */

/*
 * columnReference
 */

/*
void
columnReference() throws StandardException :
{}
{
	/*
	**
	** I re-wrote the above rule because it caused a grammar ambiguitity.
	** The problem is that we are parsing a dot-separated list of identifiers,
	** and the grammar doesn't know what the identifiers stand for, but the
	** syntax assumed that it did.  For example, in schema.table.column,
	** the grammar doesn't know when it parses the first identifier whether
	** it will be a catalog name, schema name, table name, or column name.
	**
	** I think this problem could be solved by increasing the lookahead.
	** I will try that solution next.  I like that solution better because,
	** if it works, it will be easier for the grammar to figure out what
	** each identifier stands for.
	**

	[    |
	  [ [ [   ]   ]   ]
	]
	
}
*/

/*
 * forUpdateClause
 */

/*
 * forUpdateColumnList
 */

/*
 * forUpdateColumn
 */

/*
 * setClauseList
 */

/*
 * setClause
 */

/*
 * updateSource
 */

/*
 * nullSpecification
 */

/*
 * insertColumnsAndSource
 */

/*
 * insertColumnList
 */

/*
 * columnQualifiedNameList
 */

/*
 * columnQualifiedNameItem
 */

/*
 * rowValueConstructor
 */

/*
 * rowValueConstructorElement
 */

/*
 * rowValueConstructorList
 */

/*
 * tableSubquery
 */

/*
 * subquery
 */

/*
 * inPredicateValue
 */

/*
 * inValueList
 */

/*
 * inElement
 */

/*
 * quantifier
 */

/*
 * some
 */

/*
 * existsExpression
 */

/*
 * tableExpression
 */

/*
 * fromClause
 */

/*
 * fromListProperties
 */

/* This rule created simply as a way to add the result of tableReference()
 * to the fromList.
 */

/*
 * tableReference
 */

/*
 * derivedColumnList
 */

/*
 * columnNameList
 */

/*
 * columnNameItem
 */

/*
 * indexColumnList
 */

/*
 * indexColumnItem
 */

/*
 * derivedTable
 */

/*
 * tableValueConstructor
 */

/*
 * tableValueConstructorList
 */

/*
 * explicitTable
 */

/*
 * datetimeValueFunction
 */

/*
** Note that set function and aggregate are used
** interchangeably in the parser.  The tree has
** aggregate nodes.
*/

/*
** All built in aggregates are pretty similar to user
** defined aggregates, except we know what to map to
** without looking up the class name.
**
** NOTE: COUNT is omitted here because the COUNT aggregate is
** factored into a different rule, to distinguish between
** COUNT(*) and COUNT().
*/

/*
 * charOrVarchar
 */

/*
 * dynamicParameterSpecification
 */

/*
 * whereClause
 */

/*
 * tableDefinition
 */

/*
 * DB2lockGranularityClause
 */

/*
 * lockGranularity
 */

/*
 * indexDefinition
 */

/*
 * unique
 */

/**
	CREATE PROCEDURE

	procedureElements contains the description of the procedure.
	(CREATE FUNCTIONS shares this lyout), see functionDefinition

	0 - Object[] 3 element array for parameters
	1 - TableName - specific name
	2 - Integer - dynamic result set count
	3 - String language (always java) - ignore
	4 - String external name (also passed directly to create alias node - ignore
	5 - Short parameter style (always java) - ignore 
	6 - Short - SQL allowed.
	7 - Boolean - CALLED ON NULL INPUT (always TRUE for procedures)
	8 - TypeDescriptor - return type (always NULL for procedures)
*/

/*
 * procedureParameterDefinition
 */

/**
	CREATE FUNCTION

	functionElements contains the description of the function.

	0 - Object[] 3 element array for parameters
	1 - TableName - specific name
	2 - Integer - dynamic result set count - always 0
	3 - String language (always java) - required to be set
	4 - String external name (also passed directly to create alias node - ignore
	5 - Short parameter style (always java) - required to be set 
	6 - Short - SQL allowed.
	7 - Boolean - CALLED ON NULL INPUT
	8 - TypeDescriptor - return type
*/

/*
 * functionParameterDefinition
 */

/*
 * defaultClause
 */

/*
 * defaultNullOnlyClause
 */

/*
 * generatedColumnOption
 */

//ToCleanUp
//A specific class not such long[] should exists for autoIncrementInfo ...

/*
 * autoIncrementBeginEnd
 */

/*
 * defaultOption
 */

/*
 * DB2DefaultOption
 */

/*
 * literal
 */

/*
 * numericLiteral
 */

/*
 * dateTimeLiteral
 */

/*
 * escapedDateTimeLiteral
 */

/*
 * bareDateLiteral
 */

/*
 * bareTimeLiteral
 */

/*
 * bareTimestampLiteral
 */

/*
 * string
 */

/*
 * stringLiteral
 */

/*
 * hexLiteral
 */

/*
 * DB2 requires column check constraints to refer to only that column. Cloudscape currently
 * doesn't care if check constraints are column level or table level. For DB2 compatibility
 * check that column check constraints only refer to that column.
 */

/*
 * spsRenameStatement
 */

/*
 * renameTableStatement
 */

/*
 * renameIndexStatement
 */

/*
 * simpleValueSpecification
 */

// Set the locale for messages coming from the database system. This
// is for support only, so we can get messages in our preferred language
// (usually English). I didn't want to create all the execution wiring
// to do this, so this command executes in the parser

/*
 * valueSpecification
 */

/*
 * caseExpression
 */

/*
 * whenThenExpression
 */

/*
 * thenElseExpression
 */

//the second parameter to the following method will always be null for a table level
//constraint but not for a column level constraint

/*
 * columnConstraintDefinition
 */

/*
 * columnConstraint
 */

/*
 * alterTableRenameTableStatement
 */
/*
QueryTreeNode
alterTableRenameTableStatement(TableName tableName) throws StandardException :
{
	String newTableName;
}
{
	 newTableName = identifier(Limits.MAX_IDENTIFIER_LENGTH, true)
	{
		return (QueryTreeNode) nodeFactory.getNode(
							C_NodeTypes.RENAME_NODE,
							tableName,
							null,
							newTableName,
							Boolean.TRUE,
ReuseFactory.getInteger(StatementType.RENAME_TABLE),
							getContextManager());
	}
}
*/

/*
 * alterTableRenameColumnStatement
 */
/*
QueryTreeNode
alterTableRenameColumnStatement(TableName tableName) throws StandardException :
{
	String oldColumnName;
	String newColumnName;
}
{
	oldColumnName = identifier(Limits.MAX_IDENTIFIER_LENGTH, true)  newColumnName = identifier(Limits.MAX_IDENTIFIER_LENGTH, true)
	{
		return (QueryTreeNode) nodeFactory.getNode(
							C_NodeTypes.RENAME_NODE,
							tableName,
							oldColumnName,
							newColumnName,
							Boolean.TRUE,
ReuseFactory.getInteger(StatementType.RENAME_COLUMN),
							getContextManager());
	}
}
*/

/*
 * DB2 syntax for ALTER COLUMN
 */

/*
 * dropTableStatement
 */

/*
 * dropIndexStatement
 */

/*
 * dropAliasStatement
 */

/*
 * identifier
 */

/*
 * delimitedIdentifier
 */

/*
 * reservedKeyword
 */

/*
 * nonReservedKeyword
 */

/*
 * caseSensitiveIdentifierPlusReservedWords
 */

/*
 * caseInsensitiveIdentifierPlusReservedWords
 */

/*
 * caseSensitiveIdentifier
 */