org.eigenbase.sql.validate
Class SqlValidatorImpl

java.lang.Object
  extended by 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:

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?

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':

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