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
 */

/*
 * javaType
 */

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

/*
 * javaClassName
 */

/*
 * javaDSLNameExtender
 */

/*
 * lengthAndModifier
 */

/*
 * length
 */

/*
 * exactNumber
*/

/*
 * precision
 */

/*
 * uint_value
 */

/*
 * scale
 */

/*
 * datetimeType
 */

/*
 * timePrecision
 */

/*
 * qualifiedName
 */

/*
 * queryExpression
 */

/*
 * union
 */

/*
 * nonJoinQueryTerm
 */

/*
 * 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
 */

/*
 * 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
 */

/*
 * 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
 */

/*
 * 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(DB2Limit.DB2_MAX_IDENTIFIER_LENGTH128, 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(DB2Limit.DB2_MAX_IDENTIFIER_LENGTH30, true)  newColumnName = identifier(DB2Limit.DB2_MAX_IDENTIFIER_LENGTH30, 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
 */