org.eigenbase.sql.validate
Class SqlValidatorImpl

java.lang.Object
  org.eigenbase.sql.validate.SqlValidatorImpl

All Implemented Interfaces:

SqlValidator, SqlValidatorWithHints

Direct Known Subclasses:

FarragoSqlValidator, SqlAdvisorValidator, SqlToRelTestBase.FarragoTestValidator, SqlValidatorFeatureTest.FeatureValidator

public class SqlValidatorImpl
extends Object
implements SqlValidatorWithHints

Default implementation of SqlValidator.

Since:

Mar 3, 2005

Version:

$Id: //open/dev/farrago/src/org/eigenbase/sql/validate/SqlValidatorImpl.java#96 $

Author:

jhyde

Nested Class Summary

private static class	SqlValidatorImpl.DeleteNamespace Namespace for a DELETE statement.
private class	SqlValidatorImpl.DeriveTypeVisitor Visitor which derives the type of a given SqlNode.
static class	SqlValidatorImpl.DmlNamespace Common base class for DML statement namespaces.
private static class	SqlValidatorImpl.Expander Converts an expression into canonical form by fully-qualifying any identifiers.
protected static class	SqlValidatorImpl.FunctionParamInfo Utility object used to maintain information about the parameters in a function call.
protected static class	SqlValidatorImpl.IdInfo
private static class	SqlValidatorImpl.InsertNamespace Namespace for an INSERT statement.
private static class	SqlValidatorImpl.MergeNamespace Namespace for a MERGE statement.
(package private) class	SqlValidatorImpl.OrderExpressionExpander Shuttle which walks over an expression in the ORDER BY clause, replacing usages of aliases with the underlying expression.
static class	SqlValidatorImpl.Status Validation status.
private static class	SqlValidatorImpl.UpdateNamespace Namespace for an UPDATE statement.

Nested classes/interfaces inherited from interface org.eigenbase.sql.validate.SqlValidator

SqlValidator.Compatible

Field Summary

private AggFinder	aggFinder
private AggFinder	aggOrOverFinder
private RelDataType	booleanType
(package private) SqlValidatorCatalogReader	catalogReader
private SqlConformance	conformance
private Map<SqlSelect,SqlValidatorScope>	cursorScopes Maps a SqlSelect node that is the argument to a CURSOR constructor to the scope of the result of that select node
private Set<SqlNode>	cursorSet Set of select expressions used as cursor definitions.
protected boolean	expandColumnReferences
protected boolean	expandIdentifiers
protected Stack<SqlValidatorImpl.FunctionParamInfo>	functionCallStack Stack of objects that maintain information about function calls.
protected Map<String,SqlValidatorImpl.IdInfo>	idPositions Maps ParsePosition strings to the SqlIdentifier identifier objects at these positions
protected Map<SqlNode,SqlValidatorNamespace>	namespaces Maps a node to the namespace which describes what columns they contain.
private int	nextGeneratedId
private Map<SqlNode,RelDataType>	nodeToTypeMap Map of derived RelDataType for each node.
private SqlOperatorTable	opTab
private Map<SqlSelect,SqlValidatorScope>	orderScopes Maps a SqlSelect node to the scope used by its ORDER BY clause.
private Map<SqlNode,SqlNode>	originalExprs
private boolean	rewriteCalls
protected Map<SqlNode,SqlValidatorScope>	scopes Maps query node objects to the SqlValidatorScope scope created from them}.
private Map<SqlSelect,SqlValidatorScope>	selectScopes Maps a SqlSelect node to the scope used by its SELECT and HAVING clauses.
static Logger	tracer
protected RelDataTypeFactory	typeFactory
protected RelDataType	unknownType
static String	UPDATE_ANON_PREFIX Alias prefix generated for source columns when rewriting UPDATE to MERGE.
static String	UPDATE_SRC_ALIAS Alias generated for the source table when rewriting UPDATE to MERGE.
static String	UPDATE_TGT_ALIAS Alias generated for the target table when rewriting UPDATE to MERGE if no alias was specified by the user.
private boolean	validatingSqlMerge
private Map<SqlSelect,SqlValidatorScope>	whereScopes Maps a SqlSelect node to the scope used by its WHERE and HAVING clauses.

Constructor Summary

protected

SqlValidatorImpl(SqlOperatorTable opTab, SqlValidatorCatalogReader catalogReader, RelDataTypeFactory typeFactory, SqlConformance conformance) Creates a validator.

Method Summary

protected void	addToSelectList(List<SqlNode> list, List<String> aliases, List<RelDataType> types, SqlNode exp, SqlValidatorScope scope, boolean includeSystemVars) Adds an expression to a select list, ensuring that its alias does not clash with any existing expressions on the list.
private void	checkFieldCount(SqlNode node, RelDataType logicalSourceRowType, RelDataType logicalTargetRowType)
protected void	checkTypeAssignment(RelDataType sourceRowType, RelDataType targetRowType, SqlNode query)
protected SelectNamespace	createSelectNamespace(SqlSelect select, SqlNode enclosingNode) Creates a namespace for a SELECT node.
protected SetopNamespace	createSetopNamespace(SqlCall call, SqlNode enclosingNode) Creates a namespace for a set operation (UNION, INTERSECT, or EXCEPT).
protected SqlSelect	createSourceSelectForDelete(SqlDelete call) Creates the SELECT statement that putatively feeds rows into a DELETE statement to be deleted.
protected SqlSelect	createSourceSelectForUpdate(SqlUpdate call) Creates the SELECT statement that putatively feeds rows into an UPDATE statement to be updated.
protected RelDataType	createTargetRowType(SqlValidatorTable table, SqlNodeList targetColumnList, boolean append) Derives a row-type for INSERT and UPDATE operations.
void	declareCursor(SqlSelect select, SqlValidatorScope parentScope) Declares a SELECT expression as a cursor.
String	deriveAlias(SqlNode node, int ordinal) Derives an alias for an expression.
RelDataType	deriveConstructorType(SqlValidatorScope scope, SqlCall call, SqlFunction unresolvedConstructor, SqlFunction resolvedConstructor, RelDataType[] argTypes) Derives the type of a constructor.
RelDataType	deriveType(SqlValidatorScope scope, SqlNode expr) Derives the type of a node in a given scope.
(package private) RelDataType	deriveTypeImpl(SqlValidatorScope scope, SqlNode operand) Derives the type of a node.
SqlNode	expand(SqlNode expr, SqlValidatorScope scope) Expands an expression.
SqlNode	expandOrderExpr(SqlSelect select, SqlNode orderExpr) Expands an expression in the ORDER BY clause into an expression with the same semantics as expressions in the SELECT clause.
private boolean	expandSelectItem(SqlNode selectItem, SqlSelect select, List<SqlNode> selectItems, List<String> aliases, List<RelDataType> types, boolean includeSystemVars) If selectItem is "*" or "TABLE.*", expands it and returns true; otherwise writes the unexpanded item.
SqlNodeList	expandStar(SqlNodeList selectList, SqlSelect select, boolean includeSystemVars) Returns a list of expressions, with every occurrence of "*" or "TABLE.*" expanded.
private static void	findAllValidFunctionNames(List<String> names, SqlValidator validator, List<SqlMoniker> result, SqlParserPos pos)
private static void	findAllValidUdfNames(List<String> names, SqlValidator validator, List<SqlMoniker> result)
private static <T> int	firstDuplicate(List<T> list) Returns the ordinal of the first element in the list which is equal to a previous element in the list.
SqlValidatorCatalogReader	getCatalogReader() Returns the catalog reader used by this validator.
SqlConformance	getConformance() Returns the dialect of SQL (SQL:2003, etc.) this validator recognizes.
SqlValidatorScope	getCursorScope(SqlSelect select)
SqlValidatorScope	getFromScope(SqlSelect select) Returns a scope containing the objects visible from the FROM clause of a query.
SqlValidatorScope	getGroupScope(SqlSelect select) Returns a scope containing the objects visible from the GROUP BY clause of a query.
SqlValidatorScope	getHavingScope(SqlSelect select) Returns a scope containing the objects visible from the HAVING clause of a query.
SqlValidatorScope	getJoinScope(SqlNode node) Returns a scope containing the objects visible from the ON and USING sections of a JOIN clause.
protected RelDataType	getLogicalSourceRowType(RelDataType sourceRowType, SqlInsert insert)
protected RelDataType	getLogicalTargetRowType(RelDataType targetRowType, SqlInsert insert)
SqlValidatorNamespace	getNamespace(SqlNode node) Finds the namespace corresponding to a given node.
private SqlNode	getNthExpr(SqlNode query, int ordinal, int sourceCount) Locates the n'th expression in an INSERT or UPDATE query.
SqlOperatorTable	getOperatorTable() Returns the operator table used by this validator.
SqlValidatorScope	getOrderScope(SqlSelect select) Returns the scope that expressions in the SELECT and HAVING clause of this query should use.
SqlNode	getOriginal(SqlNode expr)
SqlValidatorScope	getOverScope(SqlNode node)
String	getParentCursor(String columnListParamName) Retrieves the name of the parent cursor referenced by a column list parameter.
SelectScope	getRawSelectScope(SqlSelect select) Returns the scope for resolving the SELECT, GROUP BY and HAVING clauses.
SqlValidatorScope	getScope(SqlSelect select, int operandType) Returns the appropriate scope for validating a particular clause of a SELECT statement.
SqlValidatorScope	getSelectScope(SqlSelect select) Returns the appropriate scope for validating a particular clause of a SELECT statement.
protected SqlNode	getSelfJoinExprForUpdate(SqlIdentifier table, String alias) Allows a subclass to provide information about how to convert an UPDATE into a MERGE via self-join.
(package private) RelDataType	getTableConstructorRowType(SqlCall values, SqlValidatorScope scope)
RelDataTypeFactory	getTypeFactory() Returns the type factory used by this validator.
RelDataType	getUnknownType() Returns an object representing the "unknown" type.
RelDataType	getValidatedNodeType(SqlNode node) Returns the type assigned to a node by validation.
RelDataType	getValidatedNodeTypeIfKnown(SqlNode node) Returns the type assigned to a node by validation, or null if unknown.
SqlValidatorScope	getWhereScope(SqlSelect select) Returns the scope that expressions in the WHERE and GROUP BY clause of this query should use.
protected SqlWindow	getWindowByName(SqlIdentifier id, SqlValidatorScope scope)
private void	handleScalarSubQuery(SqlSelect parentSelect, SqlSelect selectItem, List<SqlNode> expandedSelectItems, List<String> aliasList, List<RelDataType> typeList) Processes SubQuery found in Select list.
void	handleUnresolvedFunction(SqlCall call, SqlFunction unresolvedFunction, RelDataType[] argTypes) Handles a call to a function which cannot be resolved, throwing an appropriately descriptive error.
protected void	inferUnknownTypes(RelDataType inferredType, SqlValidatorScope scope, SqlNode node)
boolean	isAggregate(SqlNode selectNode) Returns whether a select list expression is an aggregate function.
boolean	isAggregate(SqlSelect select) Returns whether a SELECT statement is an aggregation.
boolean	isSystemField(RelDataTypeField field) Returns whether a field is a system field.
(package private) SqlValidatorNamespace	lookupFieldNamespace(RelDataType rowType, String name)
private void	lookupFromHints(SqlNode node, SqlValidatorScope scope, SqlParserPos pos, List<SqlMoniker> hintList)
List<SqlMoniker>	lookupHints(SqlNode topNode, SqlParserPos pos) Looks up completion hints for a syntatically correct SQL statement that has been parsed into an expression tree.
private void	lookupJoinHints(SqlJoin join, SqlValidatorScope scope, SqlParserPos pos, List<SqlMoniker> hintList)
void	lookupNameCompletionHints(SqlValidatorScope scope, List<String> names, SqlParserPos pos, List<SqlMoniker> hintList) Populates a list of all the valid alternatives for an identifier.
SqlMoniker	lookupQualifiedName(SqlNode topNode, SqlParserPos pos) Looks up the fully qualified name for a SqlIdentifier at a given Parser Position in a parsed expression tree Note: call this only after SqlValidator.validate(org.eigenbase.sql.SqlNode) has been called.
(package private) void	lookupSelectHints(SqlSelect select, SqlParserPos pos, List<SqlMoniker> hintList) Looks up completion hints for a syntactically correct select SQL that has been parsed into an expression tree.
private void	lookupSelectHints(SqlValidatorNamespace ns, SqlParserPos pos, List<SqlMoniker> hintList)
EigenbaseException	newValidationError(SqlNode node, SqlValidatorException e) Adds "line x, column y" context to a validator exception.
protected SqlNode	performUnconditionalRewrites(SqlNode node, boolean underFrom) Performs expression rewrites which are always used unconditionally.
void	popFunctionCall() Removes the topmost entry from the function call stack.
void	pushFunctionCall() Pushes a new instance of a function call on to a function call stack.
private SqlNode	registerFrom(SqlValidatorScope parentScope, SqlValidatorScope usingScope, SqlNode node, SqlNode enclosingNode, String alias, boolean forceNullable) Registers scopes and namespaces implied a relational expression in the FROM clause.
protected void	registerNamespace(SqlValidatorScope usingScope, String alias, SqlValidatorNamespace ns, boolean forceNullable) Registers a new namespace, and adds it as a child of its parent scope.
private void	registerOperandSubqueries(SqlValidatorScope parentScope, SqlCall call, int operandOrdinal) Registers any subqueries inside a given call operand, and converts the operand to a scalar subquery if the operator requires it.
private void	registerQuery(SqlValidatorScope parentScope, SqlValidatorScope usingScope, SqlNode node, SqlNode enclosingNode, String alias, boolean forceNullable) Registers a query in a parent scope.
private void	registerQuery(SqlValidatorScope parentScope, SqlValidatorScope usingScope, SqlNode node, SqlNode enclosingNode, String alias, boolean forceNullable, boolean checkUpdate) Registers a query in a parent scope.
private void	registerSetop(SqlValidatorScope parentScope, SqlValidatorScope usingScope, SqlNode node, SqlNode enclosingNode, String alias, boolean forceNullable)
private void	registerSubqueries(SqlValidatorScope parentScope, SqlNode node)
void	removeValidatedNodeType(SqlNode node) Removes a node from the set of validated nodes
SqlWindow	resolveWindow(SqlNode windowOrRef, SqlValidatorScope scope, boolean populateBounds) Converts a window specification or window name into a fully-resolved window specification.
private void	rewriteMerge(SqlMerge call)
private SqlNode	rewriteUpdateToMerge(SqlUpdate updateCall, SqlNode selfJoinSrcExpr)
void	setCallRewrite(boolean rewriteCalls) Enables or disables rewrite of "macro-like" calls such as COALESCE.
void	setColumnReferenceExpansion(boolean expandColumnReferences) Enables or disables expansion of column references.
void	setIdentifierExpansion(boolean expandIdentifiers) Enables or disables expansion of identifiers other than column references.
void	setOriginal(SqlNode expr, SqlNode original)
void	setValidatedNodeType(SqlNode node, RelDataType type) Saves the type of a SqlNode, now that it has been validated.
(package private) void	setValidatedNodeTypeImpl(SqlNode node, RelDataType type)
protected boolean	shouldAllowIntermediateOrderBy()
protected boolean	shouldAllowOverRelation()
boolean	shouldExpandIdentifiers() Returns expansion of identifiers.
SqlNode	validate(SqlNode topNode) Validates an expression tree.
private void	validateAccess(SqlNode node, SqlValidatorTable table, SqlAccessEnum requiredAccess) Validates access to a table.
void	validateAggregateParams(SqlCall aggFunction, SqlValidatorScope scope) Validates parameters for aggregate function.
void	validateCall(SqlCall call, SqlValidatorScope scope) Validates a call to an operator.
void	validateColumnListParams(SqlFunction function, RelDataType[] argTypes, SqlNode[] operands) Validates a COLUMN_LIST parameter
void	validateDataType(SqlDataTypeSpec dataType) Validates a data type expression.
void	validateDelete(SqlDelete call) Validates a DELETE statement.
void	validateDynamicParam(SqlDynamicParam dynamicParam) Validates a dynamic parameter.
private void	validateExpr(SqlNode expr, SqlValidatorScope scope) Validates an expression.
protected void	validateFeature(org.eigenbase.resgen.ResourceDefinition feature, SqlParserPos context) Validates that a particular feature is enabled.
protected void	validateFrom(SqlNode node, RelDataType targetRowType, SqlValidatorScope scope) Validates the FROM clause of a query, or (recursively) a child node of the FROM clause: AS, OVER, JOIN, VALUES, or subquery.
protected void	validateGroupClause(SqlSelect select) Validates the GROUP BY clause of a SELECT statement.
protected void	validateHavingClause(SqlSelect select)
void	validateIdentifier(SqlIdentifier id, SqlValidatorScope scope) Resolves an identifier to a fully-qualified name.
void	validateInsert(SqlInsert insert) Validates an INSERT statement.
void	validateIntervalQualifier(SqlIntervalQualifier qualifier) Validates a SqlIntervalQualifier
protected void	validateJoin(SqlJoin join, SqlValidatorScope scope)
void	validateLiteral(SqlLiteral literal) Validates a literal.
private void	validateLiteralAsDouble(SqlLiteral literal)
void	validateMerge(SqlMerge call) Validates a MERGE statement.
protected void	validateNamespace(SqlValidatorNamespace namespace) Validates a namespace.
private void	validateNoAggs(SqlNode condition, String clause) Throws an error if there is an aggregate or windowed aggregate in the given clause.
private void	validateNodeFeature(SqlNode node)
private void	validateOrderItem(SqlSelect select, SqlNode orderItem)
protected void	validateOrderList(SqlSelect select) Validates the ORDER BY clause of a SELECT statement.
protected void	validateOver(SqlCall call, SqlValidatorScope scope)
SqlNode	validateParameterizedExpression(SqlNode topNode, Map<String,RelDataType> nameToTypeMap) Validates an expression tree.
void	validateQuery(SqlNode node, SqlValidatorScope scope) Checks that a query is valid.
private SqlNode	validateScopedExpression(SqlNode topNode, SqlValidatorScope scope)
protected void	validateSelect(SqlSelect select, RelDataType targetRowType) Validates a SELECT statement.
protected RelDataType	validateSelectList(SqlNodeList selectItems, SqlSelect select, RelDataType targetRowType)
void	validateUpdate(SqlUpdate call) Validates an UPDATE statement.
private RelDataType	validateUsingCol(SqlIdentifier id, SqlNode leftOrRight)
protected void	validateValues(SqlCall node, RelDataType targetRowType, SqlValidatorScope scope) Validates a VALUES clause.
protected void	validateWhereClause(SqlSelect select)
protected void	validateWhereOrOn(SqlValidatorScope scope, SqlNode condition, String keyword)
void	validateWindow(SqlNode windowOrId, SqlValidatorScope scope, SqlCall call) Validates the right-hand side of an OVER expression.
protected void	validateWindowClause(SqlSelect select)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

tracer

public static final Logger tracer

UPDATE_SRC_ALIAS

public static final String UPDATE_SRC_ALIAS

Alias generated for the source table when rewriting UPDATE to MERGE.

See Also:

Constant Field Values

UPDATE_TGT_ALIAS

public static final String UPDATE_TGT_ALIAS

Alias generated for the target table when rewriting UPDATE to MERGE if no alias was specified by the user.

See Also:

Constant Field Values

UPDATE_ANON_PREFIX

public static final String UPDATE_ANON_PREFIX

Alias prefix generated for source columns when rewriting UPDATE to MERGE.

See Also:

Constant Field Values

opTab

private final SqlOperatorTable opTab

catalogReader

final SqlValidatorCatalogReader catalogReader

idPositions

protected final Map<String,SqlValidatorImpl.IdInfo> idPositions

Maps ParsePosition strings to the SqlIdentifier identifier objects at these positions

scopes

protected final Map<SqlNode,SqlValidatorScope> scopes

Maps query node objects to the SqlValidatorScope scope created from them}.

whereScopes

private final Map<SqlSelect,SqlValidatorScope> whereScopes

Maps a SqlSelect node to the scope used by its WHERE and HAVING clauses.

selectScopes

private final Map<SqlSelect,SqlValidatorScope> selectScopes

Maps a SqlSelect node to the scope used by its SELECT and HAVING clauses.

orderScopes

private final Map<SqlSelect,SqlValidatorScope> orderScopes

Maps a SqlSelect node to the scope used by its ORDER BY clause.

cursorScopes

private final Map<SqlSelect,SqlValidatorScope> cursorScopes

Maps a SqlSelect node that is the argument to a CURSOR constructor to the scope of the result of that select node

namespaces

protected final Map<SqlNode,SqlValidatorNamespace> namespaces

Maps a node to the namespace which describes what columns they contain.

cursorSet

private final Set<SqlNode> cursorSet

Set of select expressions used as cursor definitions. In standard SQL, only the top-level SELECT is a cursor; Eigenbase extends this with cursors as inputs to table functions.

functionCallStack

protected final Stack<SqlValidatorImpl.FunctionParamInfo> functionCallStack

Stack of objects that maintain information about function calls. A stack is needed to handle nested function calls. The function call currently being validated is at the top of the stack.

nextGeneratedId

private int nextGeneratedId

typeFactory

protected final RelDataTypeFactory typeFactory

unknownType

protected final RelDataType unknownType

booleanType

private final RelDataType booleanType

nodeToTypeMap

private final Map<SqlNode,RelDataType> nodeToTypeMap

Map of derived RelDataType for each node. This is an IdentityHashMap since in some cases (such as null literals) we need to discriminate by instance.

aggFinder

private final AggFinder aggFinder

aggOrOverFinder

private final AggFinder aggOrOverFinder

conformance

private final SqlConformance conformance

originalExprs

private final Map<SqlNode,SqlNode> originalExprs

expandIdentifiers

protected boolean expandIdentifiers

expandColumnReferences

protected boolean expandColumnReferences

rewriteCalls

private boolean rewriteCalls

validatingSqlMerge

private boolean validatingSqlMerge

Constructor Detail

SqlValidatorImpl

protected SqlValidatorImpl(SqlOperatorTable opTab,
                           SqlValidatorCatalogReader catalogReader,
                           RelDataTypeFactory typeFactory,
                           SqlConformance conformance)

Creates a validator.

Parameters:

opTab - Operator table

catalogReader - Catalog reader

typeFactory - Type factory

conformance - Compatibility mode

"Precondition:"

opTab != null, // node is a "query expression" (per SQL standard), catalogReader != null, typeFactory != null, conformance != null

Method Detail

getConformance

public SqlConformance getConformance()

Description copied from interface: SqlValidator

Returns the dialect of SQL (SQL:2003, etc.) this validator recognizes. Default is SqlConformance.Default.

Specified by:

getConformance in interface SqlValidator

Returns:

dialect of SQL this validator recognizes

getCatalogReader

public SqlValidatorCatalogReader getCatalogReader()

Description copied from interface: SqlValidator

Returns the catalog reader used by this validator.

Specified by:

getCatalogReader in interface SqlValidator

Returns:

catalog reader

getOperatorTable

public SqlOperatorTable getOperatorTable()

Description copied from interface: SqlValidator

Returns the operator table used by this validator.

Specified by:

getOperatorTable in interface SqlValidator

Returns:

operator table

getTypeFactory

public RelDataTypeFactory getTypeFactory()

Description copied from interface: SqlValidator

Returns the type factory used by this validator.

Specified by:

getTypeFactory in interface SqlValidator

Returns:

type factory

getUnknownType

public RelDataType getUnknownType()

Description copied from interface: SqlValidator

Returns an object representing the "unknown" type.

Specified by:

getUnknownType in interface SqlValidator

Returns:

unknown type

expandStar

public SqlNodeList expandStar(SqlNodeList selectList,
                              SqlSelect select,
                              boolean includeSystemVars)

Description copied from interface: SqlValidator

Returns a list of expressions, with every occurrence of "*" or "TABLE.*" expanded.

Specified by:

expandStar in interface SqlValidator

Parameters:

selectList - Select clause to be expanded

select - Query

includeSystemVars - Whether to include system variables

Returns:

expanded select clause

declareCursor

public void declareCursor(SqlSelect select,
                          SqlValidatorScope parentScope)

Description copied from interface: SqlValidator

Declares a SELECT expression as a cursor.

Specified by:

declareCursor in interface SqlValidator

Parameters:

select - select expression associated with the cursor

parentScope - scope of the parent query associated with the cursor

pushFunctionCall

public void pushFunctionCall()

Description copied from interface: SqlValidator

Pushes a new instance of a function call on to a function call stack.

Specified by:

pushFunctionCall in interface SqlValidator

popFunctionCall

public void popFunctionCall()

Description copied from interface: SqlValidator

Removes the topmost entry from the function call stack.

Specified by:

popFunctionCall in interface SqlValidator

getParentCursor

public String getParentCursor(String columnListParamName)

Description copied from interface: SqlValidator

Retrieves the name of the parent cursor referenced by a column list parameter.

Specified by:

getParentCursor in interface SqlValidator

Parameters:

columnListParamName - name of the column list parameter

Returns:

name of the parent cursor

expandSelectItem

private boolean expandSelectItem(SqlNode selectItem,
                                 SqlSelect select,
                                 List<SqlNode> selectItems,
                                 List<String> aliases,
                                 List<RelDataType> types,
                                 boolean includeSystemVars)

If selectItem is "*" or "TABLE.*", expands it and returns true; otherwise writes the unexpanded item.

Parameters:

selectItem - Select-list item

select - Containing select clause

selectItems - List that expanded items are written to

aliases - List of aliases

types - List of data types in alias order

includeSystemVars - If true include system vars in lists

Returns:

Whether the node was expanded

validate

public SqlNode validate(SqlNode topNode)

Description copied from interface: SqlValidator

Validates an expression tree. You can call this method multiple times, but not reentrantly.

Specified by:

validate in interface SqlValidator

Parameters:

topNode - top of expression tree to be validated

Returns:

validated tree (possibly rewritten)

lookupHints

public List<SqlMoniker> lookupHints(SqlNode topNode,
                                    SqlParserPos pos)

Description copied from interface: SqlValidatorWithHints

Looks up completion hints for a syntatically correct SQL statement that has been parsed into an expression tree. (Note this should be called after SqlValidator.validate(org.eigenbase.sql.SqlNode).

Specified by:

lookupHints in interface SqlValidatorWithHints

Parameters:

topNode - top of expression tree in which to lookup completion hints

pos - indicates the position in the sql statement we want to get completion hints for. For example, "select a.ename, b.deptno from sales.emp a join sales.dept b "on a.deptno=b.deptno where empno=1"; setting pos to 'Line 1, Column 17' returns all the possible column names that can be selected from sales.dept table setting pos to 'Line 1, Column 31' returns all the possible table names in 'sales' schema

Returns:

an array of SqlMoniker (sql identifiers) that can fill in at the indicated position

lookupQualifiedName

public SqlMoniker lookupQualifiedName(SqlNode topNode,
                                      SqlParserPos pos)

Description copied from interface: SqlValidatorWithHints

Looks up the fully qualified name for a SqlIdentifier at a given Parser Position in a parsed expression tree Note: call this only after SqlValidator.validate(org.eigenbase.sql.SqlNode) has been called.

Specified by:

lookupQualifiedName in interface SqlValidatorWithHints

Parameters:

topNode - top of expression tree in which to lookup the qualfied name for the SqlIdentifier

pos - indicates the position of the SqlIdentifier in the sql statement we want to get the qualified name for

Returns:

a string of the fully qualified name of the SqlIdentifier if the Parser position represents a valid SqlIdentifier. Else return an empty string

lookupSelectHints

void lookupSelectHints(SqlSelect select,
                       SqlParserPos pos,
                       List<SqlMoniker> hintList)

Looks up completion hints for a syntactically correct select SQL that has been parsed into an expression tree.

Parameters:

select - the Select node of the parsed expression tree

pos - indicates the position in the sql statement we want to get completion hints for

hintList - list of SqlMoniker (sql identifiers) that can fill in at the indicated position

lookupSelectHints

private void lookupSelectHints(SqlValidatorNamespace ns,
                               SqlParserPos pos,
                               List<SqlMoniker> hintList)

lookupFromHints

private void lookupFromHints(SqlNode node,
                             SqlValidatorScope scope,
                             SqlParserPos pos,
                             List<SqlMoniker> hintList)

lookupJoinHints

private void lookupJoinHints(SqlJoin join,
                             SqlValidatorScope scope,
                             SqlParserPos pos,
                             List<SqlMoniker> hintList)

lookupNameCompletionHints

public final void lookupNameCompletionHints(SqlValidatorScope scope,
                                            List<String> names,
                                            SqlParserPos pos,
                                            List<SqlMoniker> hintList)

Populates a list of all the valid alternatives for an identifier.

Parameters:

scope - Validation scope

names - Components of the identifier

pos - position

hintList - a list of valid options

findAllValidUdfNames

private static void findAllValidUdfNames(List<String> names,
                                         SqlValidator validator,
                                         List<SqlMoniker> result)

findAllValidFunctionNames

private static void findAllValidFunctionNames(List<String> names,
                                              SqlValidator validator,
                                              List<SqlMoniker> result,
                                              SqlParserPos pos)

validateParameterizedExpression

public SqlNode validateParameterizedExpression(SqlNode topNode,
                                               Map<String,RelDataType> nameToTypeMap)

Description copied from interface: SqlValidator

Validates an expression tree. You can call this method multiple times, but not reentrantly.

Specified by:

validateParameterizedExpression in interface SqlValidator

Parameters:

topNode - top of expression tree to be validated

nameToTypeMap - map of simple name to RelDataType; used to resolve SqlIdentifier references

Returns:

validated tree (possibly rewritten)

validateScopedExpression

private SqlNode validateScopedExpression(SqlNode topNode,
                                         SqlValidatorScope scope)

validateQuery

public void validateQuery(SqlNode node,
                          SqlValidatorScope scope)

Description copied from interface: SqlValidator

Checks that a query is valid.

Valid queries include:

• SELECT statement,
• set operation (UNION, INTERSECT, EXCEPT)
• identifier (e.g. representing use of a table in a FROM clause)
• query aliased with the AS operator

Specified by:

validateQuery in interface SqlValidator

Parameters:

node - Query node

scope - Scope in which the query occurs

validateNamespace

protected void validateNamespace(SqlValidatorNamespace namespace)

Validates a namespace.

getCursorScope

public SqlValidatorScope getCursorScope(SqlSelect select)

getWhereScope

public SqlValidatorScope getWhereScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns the scope that expressions in the WHERE and GROUP BY clause of this query should use. This scope consists of the tables in the FROM clause, and the enclosing scope.

Specified by:

getWhereScope in interface SqlValidator

Parameters:

select - Query

Returns:

naming scope of WHERE clause

getSelectScope

public SqlValidatorScope getSelectScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns the appropriate scope for validating a particular clause of a SELECT statement.

Consider

SELECT *
 FROM foo
 WHERE EXISTS (
    SELECT deptno AS x
    FROM emp
       JOIN dept ON emp.deptno = dept.deptno
    WHERE emp.deptno = 5
    GROUP BY deptno
    ORDER BY x)

What objects can be seen in each part of the sub-query?

• In FROM (SqlValidator.getFromScope(org.eigenbase.sql.SqlSelect) , you can only see 'foo'.
• In WHERE (SqlValidator.getWhereScope(org.eigenbase.sql.SqlSelect)), GROUP BY (SqlValidator.getGroupScope(org.eigenbase.sql.SqlSelect)), SELECT (SqlValidator.getSelectScope(org.eigenbase.sql.SqlSelect)), and the ON clause of the JOIN (SqlValidator.getJoinScope(org.eigenbase.sql.SqlNode)) you can see 'emp', 'dept', and 'foo'.
• In ORDER BY (SqlValidator.getOrderScope(org.eigenbase.sql.SqlSelect)), you can see the column alias 'x'; and tables 'emp', 'dept', and 'foo'.

Specified by:

getSelectScope in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

naming scope for SELECT statement

getRawSelectScope

public SelectScope getRawSelectScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns the scope for resolving the SELECT, GROUP BY and HAVING clauses. Always a SelectScope; if this is an aggregation query, the AggregatingScope is stripped away.

Specified by:

getRawSelectScope in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

naming scope for SELECT statement, sans any aggregating scope

getHavingScope

public SqlValidatorScope getHavingScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns a scope containing the objects visible from the HAVING clause of a query.

Specified by:

getHavingScope in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

naming scope for HAVING clause

getGroupScope

public SqlValidatorScope getGroupScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns a scope containing the objects visible from the GROUP BY clause of a query.

Specified by:

getGroupScope in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

naming scope for GROUP BY clause

getFromScope

public SqlValidatorScope getFromScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns a scope containing the objects visible from the FROM clause of a query.

Specified by:

getFromScope in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

naming scope for FROM clause

getOrderScope

public SqlValidatorScope getOrderScope(SqlSelect select)

Description copied from interface: SqlValidator

Returns the scope that expressions in the SELECT and HAVING clause of this query should use. This scope consists of the FROM clause and the enclosing scope. If the query is aggregating, only columns in the GROUP BY clause may be used.

Specified by:

getOrderScope in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

naming scope for ORDER BY clause

getJoinScope

public SqlValidatorScope getJoinScope(SqlNode node)

Description copied from interface: SqlValidator

Returns a scope containing the objects visible from the ON and USING sections of a JOIN clause.

Specified by:

getJoinScope in interface SqlValidator

Parameters:

node - The item in the FROM clause which contains the ON or USING expression

Returns:

naming scope for JOIN clause

See Also:

SqlValidator.getFromScope(org.eigenbase.sql.SqlSelect)

getOverScope

public SqlValidatorScope getOverScope(SqlNode node)

getScope

public SqlValidatorScope getScope(SqlSelect select,
                                  int operandType)

Returns the appropriate scope for validating a particular clause of a SELECT statement.

Consider SELECT * FROM foo WHERE EXISTS ( SELECT deptno AS x FROM emp, dept WHERE emp.deptno = 5 GROUP BY deptno ORDER BY x) In FROM, you can only see 'foo'. In WHERE, GROUP BY and SELECT, you can see 'emp', 'dept', and 'foo'. In ORDER BY, you can see the column alias 'x', 'emp', 'dept', and 'foo'.

getNamespace

public SqlValidatorNamespace getNamespace(SqlNode node)

Description copied from interface: SqlValidator

Finds the namespace corresponding to a given node.

For example, in the query SELECT * FROM (SELECT * FROM t), t1 AS alias, the both items in the FROM clause have a corresponding namespace.

Specified by:

getNamespace in interface SqlValidator

Parameters:

node - Parse tree node

Returns:

namespace of node

performUnconditionalRewrites

protected SqlNode performUnconditionalRewrites(SqlNode node,
                                               boolean underFrom)

Performs expression rewrites which are always used unconditionally. These rewrites massage the expression tree into a standard form so that the rest of the validation logic can be simpler.

Parameters:

node - expression to be rewritten

underFrom - whether node appears directly under a FROM clause

Returns:

rewritten expression

rewriteMerge

private void rewriteMerge(SqlMerge call)

rewriteUpdateToMerge

private SqlNode rewriteUpdateToMerge(SqlUpdate updateCall,
                                     SqlNode selfJoinSrcExpr)

getSelfJoinExprForUpdate

protected SqlNode getSelfJoinExprForUpdate(SqlIdentifier table,
                                           String alias)

Allows a subclass to provide information about how to convert an UPDATE into a MERGE via self-join. If this method returns null, then no such conversion takes place. Otherwise, this method should return a suitable unique identifier expression for the given table.

Parameters:

table - identifier for table being updated

alias - alias to use for qualifying columns in expression, or null for unqualified references; if this is equal to "SYS$SRC", then column references have been anonymized to "SYS$ANONx", where x is the 1-based column number.

Returns:

expression for unique identifier, or null to prevent conversion

createSourceSelectForUpdate

protected SqlSelect createSourceSelectForUpdate(SqlUpdate call)

Creates the SELECT statement that putatively feeds rows into an UPDATE statement to be updated.

Parameters:

call - Call to the UPDATE operator

Returns:

select statement

createSourceSelectForDelete

protected SqlSelect createSourceSelectForDelete(SqlDelete call)

Creates the SELECT statement that putatively feeds rows into a DELETE statement to be deleted.

Parameters:

call - Call to the DELETE operator

Returns:

select statement

getTableConstructorRowType

RelDataType getTableConstructorRowType(SqlCall values,
                                       SqlValidatorScope scope)

getValidatedNodeType

public RelDataType getValidatedNodeType(SqlNode node)

Description copied from interface: SqlValidator

Returns the type assigned to a node by validation.

Specified by:

getValidatedNodeType in interface SqlValidator

Parameters:

node - the node of interest

Returns:

validated type, never null

getValidatedNodeTypeIfKnown

public RelDataType getValidatedNodeTypeIfKnown(SqlNode node)

Description copied from interface: SqlValidator

Returns the type assigned to a node by validation, or null if unknown. This allows for queries against nodes such as aliases, which have no type of their own. If you want to assert that the node of interest must have a type, use SqlValidator.getValidatedNodeType(org.eigenbase.sql.SqlNode) instead.

Specified by:

getValidatedNodeTypeIfKnown in interface SqlValidator

Parameters:

node - the node of interest

Returns:

validated type, or null if unknown or not applicable

setValidatedNodeType

public void setValidatedNodeType(SqlNode node,
                                 RelDataType type)

Description copied from interface: SqlValidator

Saves the type of a SqlNode, now that it has been validated.

Specified by:

setValidatedNodeType in interface SqlValidator

Parameters:

node - A SQL parse tree node

type - Its type; must not be null

removeValidatedNodeType

public void removeValidatedNodeType(SqlNode node)

Description copied from interface: SqlValidator

Removes a node from the set of validated nodes

Specified by:

removeValidatedNodeType in interface SqlValidator

Parameters:

node - node to be removed

setValidatedNodeTypeImpl

void setValidatedNodeTypeImpl(SqlNode node,
                              RelDataType type)

deriveType

public RelDataType deriveType(SqlValidatorScope scope,
                              SqlNode expr)

Description copied from interface: SqlValidator

Derives the type of a node in a given scope. If the type has already been inferred, returns the previous type.

Specified by:

deriveType in interface SqlValidator

Parameters:

scope - Syntactic scope

expr - Parse tree node

Returns:

Type of the SqlNode. Should never return NULL

deriveTypeImpl

RelDataType deriveTypeImpl(SqlValidatorScope scope,
                           SqlNode operand)

Derives the type of a node.

"Postcondition:"

return != null

deriveConstructorType

public RelDataType deriveConstructorType(SqlValidatorScope scope,
                                         SqlCall call,
                                         SqlFunction unresolvedConstructor,
                                         SqlFunction resolvedConstructor,
                                         RelDataType[] argTypes)

Description copied from interface: SqlValidator

Derives the type of a constructor.

Specified by:

deriveConstructorType in interface SqlValidator

Parameters:

scope - Scope

call - Call

unresolvedConstructor - TODO

resolvedConstructor - TODO

argTypes - Types of arguments

Returns:

Resolved type of constructor

handleUnresolvedFunction

public void handleUnresolvedFunction(SqlCall call,
                                     SqlFunction unresolvedFunction,
                                     RelDataType[] argTypes)

Description copied from interface: SqlValidator

Handles a call to a function which cannot be resolved, throwing an appropriately descriptive error.

Specified by:

handleUnresolvedFunction in interface SqlValidator

Parameters:

call - Call

unresolvedFunction - Overloaded function which is the target of the call

argTypes - Types of arguments

inferUnknownTypes

protected void inferUnknownTypes(RelDataType inferredType,
                                 SqlValidatorScope scope,
                                 SqlNode node)

addToSelectList

protected void addToSelectList(List<SqlNode> list,
                               List<String> aliases,
                               List<RelDataType> types,
                               SqlNode exp,
                               SqlValidatorScope scope,
                               boolean includeSystemVars)

Adds an expression to a select list, ensuring that its alias does not clash with any existing expressions on the list.

deriveAlias

public String deriveAlias(SqlNode node,
                          int ordinal)

Description copied from interface: SqlValidator

Derives an alias for an expression. If no alias can be derived, returns null if ordinal is less than zero, otherwise generates an alias EXPR$ordinal.

Specified by:

deriveAlias in interface SqlValidator

Parameters:

node - Expression

ordinal - Ordinal of expression

Returns:

derived alias, or null if no alias can be derived and ordinal is less than zero

setIdentifierExpansion

public void setIdentifierExpansion(boolean expandIdentifiers)

Description copied from interface: SqlValidator

Enables or disables expansion of identifiers other than column references.

Specified by:

setIdentifierExpansion in interface SqlValidator

Parameters:

expandIdentifiers - new setting

setColumnReferenceExpansion

public void setColumnReferenceExpansion(boolean expandColumnReferences)

Description copied from interface: SqlValidator

Enables or disables expansion of column references. (Currently this does not apply to the ORDER BY clause; may be fixed in the future.)

Specified by:

setColumnReferenceExpansion in interface SqlValidator

Parameters:

expandColumnReferences - new setting

setCallRewrite

public void setCallRewrite(boolean rewriteCalls)

Description copied from interface: SqlValidator

Enables or disables rewrite of "macro-like" calls such as COALESCE.

Specified by:

setCallRewrite in interface SqlValidator

Parameters:

rewriteCalls - new setting

shouldExpandIdentifiers

public boolean shouldExpandIdentifiers()

Description copied from interface: SqlValidator

Returns expansion of identifiers.

Specified by:

shouldExpandIdentifiers in interface SqlValidator

Returns:

whether this validator should expand identifiers

shouldAllowIntermediateOrderBy

protected boolean shouldAllowIntermediateOrderBy()

registerNamespace

protected void registerNamespace(SqlValidatorScope usingScope,
                                 String alias,
                                 SqlValidatorNamespace ns,
                                 boolean forceNullable)

Registers a new namespace, and adds it as a child of its parent scope. Derived class can override this method to tinker with namespaces as they are created.

Parameters:

usingScope - Parent scope (which will want to look for things in this namespace)

alias - Alias by which parent will refer to this namespace

ns - Namespace

forceNullable - Whether to force the type of namespace to be

registerFrom

private SqlNode registerFrom(SqlValidatorScope parentScope,
                             SqlValidatorScope usingScope,
                             SqlNode node,
                             SqlNode enclosingNode,
                             String alias,
                             boolean forceNullable)

Registers scopes and namespaces implied a relational expression in the FROM clause.

parentScope and usingScope are often the same. They differ when the namespace are not visible within the parent. (Example needed.)

Likewise, enclosingNode and node are often the same. enclosingNode is the topmost node within the FROM clause, from which any decorations like an alias (AS alias) or a table sample clause are stripped away to get node. Both are recorded in the namespace.

Parameters:

parentScope - Parent scope which this scope turns to in order to resolve objects

usingScope - Scope whose child list this scope should add itself to

node - Node which namespace is based on

enclosingNode - Outermost node for namespace, including decorations such as alias and sample clause

alias - Alias

forceNullable - Whether to force the type of namespace to be nullable because it is in an outer join

Returns:

registered node, usually the same as node

shouldAllowOverRelation

protected boolean shouldAllowOverRelation()

createSelectNamespace

protected SelectNamespace createSelectNamespace(SqlSelect select,
                                                SqlNode enclosingNode)

Creates a namespace for a SELECT node. Derived class may override this factory method.

Parameters:

select - Select node

enclosingNode - Enclosing node

Returns:

Select namespace

createSetopNamespace

protected SetopNamespace createSetopNamespace(SqlCall call,
                                              SqlNode enclosingNode)

Creates a namespace for a set operation (UNION, INTERSECT, or EXCEPT). Derived class may override this factory method.

Parameters:

call - Call to set operation

enclosingNode - Enclosing node

Returns:

Set operation namespace

registerQuery

private void registerQuery(SqlValidatorScope parentScope,
                           SqlValidatorScope usingScope,
                           SqlNode node,
                           SqlNode enclosingNode,
                           String alias,
                           boolean forceNullable)

Registers a query in a parent scope.

Parameters:

parentScope - Parent scope which this scope turns to in order to resolve objects

usingScope - Scope whose child list this scope should add itself to

node - Query node

alias - Name of this query within its parent. Must be specified if usingScope != null

"Precondition:"

usingScope == null || alias != null

registerQuery

private void registerQuery(SqlValidatorScope parentScope,
                           SqlValidatorScope usingScope,
                           SqlNode node,
                           SqlNode enclosingNode,
                           String alias,
                           boolean forceNullable,
                           boolean checkUpdate)

Registers a query in a parent scope.

Parameters:

parentScope - Parent scope which this scope turns to in order to resolve objects

usingScope - Scope whose child list this scope should add itself to

node - Query node

alias - Name of this query within its parent. Must be specified if usingScope != null

checkUpdate - if true, validate that the update feature is supported if validating the update statement

"Precondition:"

usingScope == null || alias != null

registerSetop

private void registerSetop(SqlValidatorScope parentScope,
                           SqlValidatorScope usingScope,
                           SqlNode node,
                           SqlNode enclosingNode,
                           String alias,
                           boolean forceNullable)

isAggregate

public boolean isAggregate(SqlSelect select)

Description copied from interface: SqlValidator

Returns whether a SELECT statement is an aggregation. Criteria are: (1) contains GROUP BY, or (2) contains HAVING, or (3) SELECT or ORDER BY clause contains aggregate functions. (Windowed aggregate functions, such as SUM(x) OVER w, don't count.)

Specified by:

isAggregate in interface SqlValidator

Parameters:

select - SELECT statement

Returns:

whether SELECT statement is an aggregation

isAggregate

public boolean isAggregate(SqlNode selectNode)

Description copied from interface: SqlValidator

Returns whether a select list expression is an aggregate function.

Specified by:

isAggregate in interface SqlValidator

Parameters:

selectNode - Expression in SELECT clause

Returns:

whether expression is an aggregate function

validateNodeFeature

private void validateNodeFeature(SqlNode node)

registerSubqueries

private void registerSubqueries(SqlValidatorScope parentScope,
                                SqlNode node)

registerOperandSubqueries

private void registerOperandSubqueries(SqlValidatorScope parentScope,
                                       SqlCall call,
                                       int operandOrdinal)

Registers any subqueries inside a given call operand, and converts the operand to a scalar subquery if the operator requires it.

Parameters:

parentScope - Parent scope

call - Call

operandOrdinal - Ordinal of operand within call

See Also:

SqlOperator.argumentMustBeScalar(int)

validateIdentifier

public void validateIdentifier(SqlIdentifier id,
                               SqlValidatorScope scope)

Description copied from interface: SqlValidator

Resolves an identifier to a fully-qualified name.

Specified by:

validateIdentifier in interface SqlValidator

Parameters:

id - Identifier

scope - Naming scope

validateLiteral

public void validateLiteral(SqlLiteral literal)

Description copied from interface: SqlValidator

Validates a literal.

Specified by:

validateLiteral in interface SqlValidator

Parameters:

literal - Literal

validateLiteralAsDouble

private void validateLiteralAsDouble(SqlLiteral literal)

validateIntervalQualifier

public void validateIntervalQualifier(SqlIntervalQualifier qualifier)

Description copied from interface: SqlValidator

Validates a SqlIntervalQualifier

Specified by:

validateIntervalQualifier in interface SqlValidator

Parameters:

qualifier - Interval qualifier

validateFrom

protected void validateFrom(SqlNode node,
                            RelDataType targetRowType,
                            SqlValidatorScope scope)

Validates the FROM clause of a query, or (recursively) a child node of the FROM clause: AS, OVER, JOIN, VALUES, or subquery.

Parameters:

node - Node in FROM clause, typically a table or derived table

targetRowType - Desired row type of this expression, or unknownType if not fussy. Must not be null.

scope - Scope

validateOver

protected void validateOver(SqlCall call,
                            SqlValidatorScope scope)

validateJoin

protected void validateJoin(SqlJoin join,
                            SqlValidatorScope scope)

validateNoAggs

private void validateNoAggs(SqlNode condition,
                            String clause)

Throws an error if there is an aggregate or windowed aggregate in the given clause.

Parameters:

condition - Parse tree

clause - Name of clause: "WHERE", "GROUP BY", "ON"

validateUsingCol

private RelDataType validateUsingCol(SqlIdentifier id,
                                     SqlNode leftOrRight)

validateSelect

protected void validateSelect(SqlSelect select,
                              RelDataType targetRowType)

Validates a SELECT statement.

Parameters:

select - Select statement

targetRowType - Desired row type, must not be null, may be the data type 'unknown'.

"Precondition:"

targetRowType != null

firstDuplicate

private static <T> int firstDuplicate(List<T> list)

Returns the ordinal of the first element in the list which is equal to a previous element in the list.

For example, firstDuplicate(Arrays.asList("a", "b", "c", "b", "a")) returns 3, the ordinal of the 2nd "b".

Parameters:

list - List

Returns:

Ordinal of first duplicate, or -1 if not found

validateWindowClause

protected void validateWindowClause(SqlSelect select)

validateOrderList

protected void validateOrderList(SqlSelect select)

Validates the ORDER BY clause of a SELECT statement.

Parameters:

select - Select statement

validateOrderItem

private void validateOrderItem(SqlSelect select,
                               SqlNode orderItem)

expandOrderExpr

public SqlNode expandOrderExpr(SqlSelect select,
                               SqlNode orderExpr)

Description copied from interface: SqlValidator

Expands an expression in the ORDER BY clause into an expression with the same semantics as expressions in the SELECT clause.

This is made necessary by a couple of dialect 'features':

• ordinal expressions: In "SELECT x, y FROM t ORDER BY 2", the expression "2" is shorthand for the 2nd item in the select clause, namely "y".
• alias references: In "SELECT x AS a, y FROM t ORDER BY a", the expression "a" is shorthand for the item in the select clause whose alias is "a"

Specified by:

expandOrderExpr in interface SqlValidator

Parameters:

select - Select statement which contains ORDER BY

orderExpr - Expression in the ORDER BY clause.

Returns:

Expression translated into SELECT clause semantics

validateGroupClause

protected void validateGroupClause(SqlSelect select)

Validates the GROUP BY clause of a SELECT statement. This method is called even if no GROUP BY clause is present.

validateWhereClause

protected void validateWhereClause(SqlSelect select)

validateWhereOrOn

protected void validateWhereOrOn(SqlValidatorScope scope,
                                 SqlNode condition,
                                 String keyword)

validateHavingClause

protected void validateHavingClause(SqlSelect select)

validateSelectList

protected RelDataType validateSelectList(SqlNodeList selectItems,
                                         SqlSelect select,
                                         RelDataType targetRowType)

validateExpr

private void validateExpr(SqlNode expr,
                          SqlValidatorScope scope)

Validates an expression.

Parameters:

expr - Expression

scope - Scope in which expression occurs

handleScalarSubQuery

private void handleScalarSubQuery(SqlSelect parentSelect,
                                  SqlSelect selectItem,
                                  List<SqlNode> expandedSelectItems,
                                  List<String> aliasList,
                                  List<RelDataType> typeList)

Processes SubQuery found in Select list. Checks that is actually Scalar subquery and makes proper entries in each of the 3 lists used to create the final rowType entry.

Parameters:

parentSelect - base SqlSelect item

selectItem - child SqlSelect from select list

expandedSelectItems - Select items after processing

aliasList - built from user or system values

typeList - Built up entries for each select list entry

createTargetRowType

protected RelDataType createTargetRowType(SqlValidatorTable table,
                                          SqlNodeList targetColumnList,
                                          boolean append)

Derives a row-type for INSERT and UPDATE operations.

Parameters:

table - Target table for INSERT/UPDATE

targetColumnList - List of target columns, or null if not specified

append - Whether to append fields to those in baseRowType

Returns:

Rowtype

validateInsert

public void validateInsert(SqlInsert insert)

Description copied from interface: SqlValidator

Validates an INSERT statement.

Specified by:

validateInsert in interface SqlValidator

Parameters:

insert - INSERT statement

checkFieldCount

private void checkFieldCount(SqlNode node,
                             RelDataType logicalSourceRowType,
                             RelDataType logicalTargetRowType)

getLogicalTargetRowType

protected RelDataType getLogicalTargetRowType(RelDataType targetRowType,
                                              SqlInsert insert)

getLogicalSourceRowType

protected RelDataType getLogicalSourceRowType(RelDataType sourceRowType,
                                              SqlInsert insert)

checkTypeAssignment

protected void checkTypeAssignment(RelDataType sourceRowType,
                                   RelDataType targetRowType,
                                   SqlNode query)

getNthExpr

private SqlNode getNthExpr(SqlNode query,
                           int ordinal,
                           int sourceCount)

Locates the n'th expression in an INSERT or UPDATE query.

Parameters:

query - Query

ordinal - Ordinal of expression

sourceCount - Number of expressions

Returns:

Ordinal'th expression, never null

validateDelete

public void validateDelete(SqlDelete call)

Description copied from interface: SqlValidator

Validates a DELETE statement.

Specified by:

validateDelete in interface SqlValidator

Parameters:

call - DELETE statement

validateUpdate

public void validateUpdate(SqlUpdate call)

Description copied from interface: SqlValidator

Validates an UPDATE statement.

Specified by:

validateUpdate in interface SqlValidator

Parameters:

call - UPDATE statement

validateMerge

public void validateMerge(SqlMerge call)

Description copied from interface: SqlValidator

Validates a MERGE statement.

Specified by:

validateMerge in interface SqlValidator

Parameters:

call - MERGE statement

validateAccess

private void validateAccess(SqlNode node,
                            SqlValidatorTable table,
                            SqlAccessEnum requiredAccess)

Validates access to a table.

Parameters:

table - Table

requiredAccess - Access requested on table

validateValues

protected void validateValues(SqlCall node,
                              RelDataType targetRowType,
                              SqlValidatorScope scope)

Validates a VALUES clause.

Parameters:

node - Values clause

targetRowType - Row type which expression must conform to

scope - Scope within which clause occurs

validateDataType

public void validateDataType(SqlDataTypeSpec dataType)

Description copied from interface: SqlValidator

Validates a data type expression.

Specified by:

validateDataType in interface SqlValidator

Parameters:

dataType - Data type

validateDynamicParam

public void validateDynamicParam(SqlDynamicParam dynamicParam)

Description copied from interface: SqlValidator

Validates a dynamic parameter.

Specified by:

validateDynamicParam in interface SqlValidator

Parameters:

dynamicParam - Dynamic parameter

newValidationError

public EigenbaseException newValidationError(SqlNode node,
                                             SqlValidatorException e)

Description copied from interface: SqlValidator

Adds "line x, column y" context to a validator exception.

Note that the input exception is checked (it derives from Exception) and the output exception is unchecked (it derives from RuntimeException). This is intentional -- it should remind code authors to provide context for their validation errors.

Specified by:

newValidationError in interface SqlValidator

Parameters:

node - The place where the exception occurred

e - The validation error

Returns:

Exception containing positional information

getWindowByName

protected SqlWindow getWindowByName(SqlIdentifier id,
                                    SqlValidatorScope scope)

resolveWindow

public SqlWindow resolveWindow(SqlNode windowOrRef,
                               SqlValidatorScope scope,
                               boolean populateBounds)

Description copied from interface: SqlValidator

Converts a window specification or window name into a fully-resolved window specification. For example, in SELECT sum(x) OVER (PARTITION BY x ORDER BY y), sum(y) OVER w1, sum(z) OVER (w ORDER BY y) FROM t WINDOW w AS (PARTITION BY x) all aggregations have the same resolved window specification (PARTITION BY x ORDER BY y).

Specified by:

resolveWindow in interface SqlValidator

Parameters:

windowOrRef - Either the name of a window (a SqlIdentifier) or a window specification (a SqlWindow).

scope - Scope in which to resolve window names

populateBounds - Whether to populate bounds. Doing so may alter the definition of the window. It is recommended that populate bounds when translating to physical algebra, but not when validating.

Returns:

A window

getOriginal

public SqlNode getOriginal(SqlNode expr)

setOriginal

public void setOriginal(SqlNode expr,
                        SqlNode original)

lookupFieldNamespace

SqlValidatorNamespace lookupFieldNamespace(RelDataType rowType,
                                           String name)

validateWindow

public void validateWindow(SqlNode windowOrId,
                           SqlValidatorScope scope,
                           SqlCall call)

Description copied from interface: SqlValidator

Validates the right-hand side of an OVER expression. It might be either an identifier referencing a window, or an inline window specification.

Specified by:

validateWindow in interface SqlValidator

Parameters:

windowOrId - SqlNode that can be either SqlWindow with all the components of a window spec or a SqlIdentifier with the name of a window spec.

scope - Naming scope

call - is the SqlNode if a function call if the window is attached to one.

validateAggregateParams

public void validateAggregateParams(SqlCall aggFunction,
                                    SqlValidatorScope scope)

Description copied from interface: SqlValidator

Validates parameters for aggregate function.

Specified by:

validateAggregateParams in interface SqlValidator

Parameters:

aggFunction - function containing COLUMN_LIST parameter

scope - Syntactic scope

validateCall

public void validateCall(SqlCall call,
                         SqlValidatorScope scope)

Description copied from interface: SqlValidator

Validates a call to an operator.

Specified by:

validateCall in interface SqlValidator

Parameters:

call - Operator call

scope - Naming scope

validateFeature

protected void validateFeature(org.eigenbase.resgen.ResourceDefinition feature,
                               SqlParserPos context)

Validates that a particular feature is enabled. By default, all features are enabled; subclasses may override this method to be more discriminating.

Parameters:

feature - feature being used, represented as a resource definition from EigenbaseResource

context - parser position context for error reporting, or null if none available

expand

public SqlNode expand(SqlNode expr,
                      SqlValidatorScope scope)

Description copied from interface: SqlValidator

Expands an expression.

Specified by:

expand in interface SqlValidator

Parameters:

expr - Expression

scope - Scope

Returns:

Expanded expression

isSystemField

public boolean isSystemField(RelDataTypeField field)

Description copied from interface: SqlValidator

Returns whether a field is a system field. Such fields may have particular properties such as sortedness and nullability.

In the default implementation, always returns false.

Specified by:

isSystemField in interface SqlValidator

Parameters:

field - Field

Returns:

whether field is a system field

validateColumnListParams

public void validateColumnListParams(SqlFunction function,
                                     RelDataType[] argTypes,
                                     SqlNode[] operands)

Description copied from interface: SqlValidator

Validates a COLUMN_LIST parameter

Specified by:

validateColumnListParams in interface SqlValidator

Parameters:

function - function containing COLUMN_LIST parameter

argTypes - function arguments

operands - operands passed into the function call