Inheritance diagram for org.apache.calcite.sql.validate.SqlValidatorImpl:

Collaboration diagram for org.apache.calcite.sql.validate.SqlValidatorImpl:

Classes
enum	Clause

class	DeleteNamespace

class	DeriveTypeVisitor

class	DmlNamespace

class	Expander

class	ExtendedExpander

class	FunctionParamInfo

class	IdInfo

class	InsertNamespace

class	MergeNamespace

class	NavigationExpander

class	NavigationModifier

class	NavigationReplacer

class	OrderExpressionExpander

class	PatternValidator

class	PatternVarVisitor

class	Permute

class	SelectExpander

enum	Status

class	UpdateNamespace

class	ValidationError

class	ValidationErrorFunction

Public Member Functions
SqlConformance	getConformance ()

SqlValidatorCatalogReader	getCatalogReader ()

SqlOperatorTable	getOperatorTable ()

RelDataTypeFactory	getTypeFactory ()

RelDataType	getUnknownType ()

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

void	declareCursor (SqlSelect select, SqlValidatorScope parentScope)

void	pushFunctionCall ()

void	popFunctionCall ()

String	getParentCursor (String columnListParamName)

List< String >	usingNames (SqlJoin join)

SqlNode	validate (SqlNode topNode)

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

SqlMoniker	lookupQualifiedName (SqlNode topNode, SqlParserPos pos)

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

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

void	validateQuery (SqlNode node, SqlValidatorScope scope, RelDataType targetRowType)

SqlValidatorScope	getEmptyScope ()

SqlValidatorScope	getCursorScope (SqlSelect select)

SqlValidatorScope	getWhereScope (SqlSelect select)

SqlValidatorScope	getSelectScope (SqlSelect select)

SelectScope	getRawSelectScope (SqlSelect select)

SqlValidatorScope	getHavingScope (SqlSelect select)

SqlValidatorScope	getGroupScope (SqlSelect select)

SqlValidatorScope	getFromScope (SqlSelect select)

SqlValidatorScope	getOrderScope (SqlSelect select)

SqlValidatorScope	getMatchRecognizeScope (SqlMatchRecognize node)

SqlValidatorScope	getJoinScope (SqlNode node)

SqlValidatorScope	getOverScope (SqlNode node)

SqlValidatorNamespace	getNamespace (SqlNode node)

RelDataType	getValidatedNodeType (SqlNode node)

RelDataType	getValidatedNodeTypeIfKnown (SqlNode node)

final void	setValidatedNodeType (SqlNode node, RelDataType type)

void	removeValidatedNodeType (SqlNode node)

SqlCall	makeNullaryCall (SqlIdentifier id)

RelDataType	deriveType (SqlValidatorScope scope, SqlNode expr)

RelDataType	deriveConstructorType (SqlValidatorScope scope, SqlCall call, SqlFunction unresolvedConstructor, SqlFunction resolvedConstructor, List< RelDataType > argTypes)

CalciteException	handleUnresolvedFunction (SqlCall call, SqlFunction unresolvedFunction, List< RelDataType > argTypes, List< String > argNames)

String	deriveAlias (SqlNode node, int ordinal)

boolean	isAggregate (SqlSelect select)

boolean	isAggregate (SqlNode selectNode)

void	validateIdentifier (SqlIdentifier id, SqlValidatorScope scope)

void	validateLiteral (SqlLiteral literal)

void	validateIntervalQualifier (SqlIntervalQualifier qualifier)

boolean	validateModality (SqlSelect select, SqlModality modality, boolean fail)

void	validateWith (SqlWith with, SqlValidatorScope scope)

void	validateWithItem (SqlWithItem withItem)

void	validateSequenceValue (SqlValidatorScope scope, SqlIdentifier id)

SqlValidatorScope	getWithScope (SqlNode withItem)

TypeCoercion	getTypeCoercion ()

Config	config ()

SqlValidator	transform (UnaryOperator< Config > transform)

SqlNode	expandOrderExpr (SqlSelect select, SqlNode orderExpr)

void	validateInsert (SqlInsert insert)

void	validateDelete (SqlDelete call)

void	validateUpdate (SqlUpdate call)

void	validateMerge (SqlMerge call)

void	validateDataType (SqlDataTypeSpec dataType)

void	validateDynamicParam (SqlDynamicParam dynamicParam)

ValidationErrorFunction	getValidationErrorFunction ()

CalciteContextException	newValidationError (SqlNode node, Resources.ExInst< SqlValidatorException > e)

SqlWindow	resolveWindow (SqlNode windowOrRef, SqlValidatorScope scope)

SqlNode	getOriginal (SqlNode expr)

void	setOriginal (SqlNode expr, SqlNode original)

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

void	validateMatchRecognize (SqlCall call)

void	validateAggregateParams (SqlCall aggCall, SqlNode filter, SqlNodeList orderList, SqlValidatorScope scope)

void	validateCall (SqlCall call, SqlValidatorScope scope)

SqlNode	expandSelectExpr (SqlNode expr, SelectScope scope, SqlSelect select)

SqlNode	expand (SqlNode expr, SqlValidatorScope scope)

SqlNode	expandGroupByOrHavingExpr (SqlNode expr, SqlValidatorScope scope, SqlSelect select, boolean havingExpression)

boolean	isSystemField (RelDataTypeField field)

List< List< String > >	getFieldOrigins (SqlNode sqlQuery)

RelDataType	getParameterRowType (SqlNode sqlQuery)

void	validateColumnListParams (SqlFunction function, List< RelDataType > argTypes, List< SqlNode > operands)

Static Public Attributes
static final Logger	TRACER = CalciteTrace.PARSER_LOGGER

static final String	UPDATE_SRC_ALIAS = "SYS$SRC"

static final String	UPDATE_TGT_ALIAS = "SYS$TGT"

static final String	UPDATE_ANON_PREFIX = "SYS$ANON"

Protected Member Functions
	SqlValidatorImpl (SqlOperatorTable opTab, SqlValidatorCatalogReader catalogReader, RelDataTypeFactory typeFactory, Config config)

void	validateNamespace (final SqlValidatorNamespace namespace, RelDataType targetRowType)

SqlNode	performUnconditionalRewrites (SqlNode node, boolean underFrom)

SqlNode	getSelfJoinExprForUpdate (SqlNode table, String alias)

SqlSelect	createSourceSelectForUpdate (SqlUpdate call)

SqlSelect	createSourceSelectForDelete (SqlDelete call)

void	inferUnknownTypes (@Nonnull RelDataType inferredType,@Nonnull SqlValidatorScope scope,@Nonnull SqlNode node)

void	addToSelectList (List< SqlNode > list, Set< String > aliases, List< Map.Entry< String, RelDataType >> fieldList, SqlNode exp, SelectScope scope, final boolean includeSystemVars)

boolean	shouldAllowIntermediateOrderBy ()

MatchRecognizeNamespace	createMatchRecognizeNameSpace (SqlMatchRecognize call, SqlNode enclosingNode)

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

boolean	shouldAllowOverRelation ()

SelectNamespace	createSelectNamespace (SqlSelect select, SqlNode enclosingNode)

SetopNamespace	createSetopNamespace (SqlCall call, SqlNode enclosingNode)

boolean	isNestedAggregateWindow (SqlNode node)

boolean	isOverAggregateWindow (SqlNode node)

SqlNode	getAggregate (SqlSelect select)

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

void	validateOver (SqlCall call, SqlValidatorScope scope)

void	validateUnnest (SqlCall call, SqlValidatorScope scope, RelDataType targetRowType)

void	validateJoin (SqlJoin join, SqlValidatorScope scope)

void	validateSelect (SqlSelect select, RelDataType targetRowType)

void	validateWindowClause (SqlSelect select)

void	validateOrderList (SqlSelect select)

void	validateGroupClause (SqlSelect select)

void	validateWhereClause (SqlSelect select)

void	validateWhereOrOn (SqlValidatorScope scope, SqlNode condition, String clause)

void	validateHavingClause (SqlSelect select)

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

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

RelDataType	getLogicalTargetRowType (RelDataType targetRowType, SqlInsert insert)

RelDataType	getLogicalSourceRowType (RelDataType sourceRowType, SqlInsert insert)

void	checkTypeAssignment (SqlValidatorScope sourceScope, SqlValidatorTable table, RelDataType sourceRowType, RelDataType targetRowType, final SqlNode query)

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

SqlWindow	getWindowByName (SqlIdentifier id, SqlValidatorScope scope)

void	validateFeature (Feature feature, SqlParserPos context)

Protected Attributes
final Map< String, IdInfo >	idPositions = new HashMap<>()

final Map< SqlNode, SqlValidatorScope >	scopes

final Map< SqlNode, SqlValidatorNamespace >	namespaces

final Deque< FunctionParamInfo >	functionCallStack

final RelDataTypeFactory	typeFactory

final RelDataType	unknownType

Package Functions
void	lookupSelectHints (SqlSelect select, SqlParserPos pos, Collection< SqlMoniker > hintList)

RelDataType	getTableConstructorRowType (SqlCall values, SqlValidatorScope scope)

RelDataType	deriveTypeImpl (SqlValidatorScope scope, SqlNode operand)

SqlValidatorNamespace	lookupFieldNamespace (RelDataType rowType, String name)

Package Attributes
final SqlValidatorCatalogReader	catalogReader

Private Member Functions
boolean	expandSelectItem (final SqlNode selectItem, SqlSelect select, RelDataType targetType, List< SqlNode > selectItems, Set< String > aliases, List< Map.Entry< String, RelDataType >> fields, final boolean includeSystemVars)

boolean	expandStar (List< SqlNode > selectItems, Set< String > aliases, List< Map.Entry< String, RelDataType >> fields, boolean includeSystemVars, SelectScope scope, SqlNode node)

SqlNode	maybeCast (SqlNode node, RelDataType currentType, RelDataType desiredType)

boolean	addOrExpandField (List< SqlNode > selectItems, Set< String > aliases, List< Map.Entry< String, RelDataType >> fields, boolean includeSystemVars, SelectScope scope, SqlIdentifier id, RelDataTypeField field)

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

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

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

SqlNode	validateScopedExpression (SqlNode topNode, SqlValidatorScope scope)

SqlValidatorNamespace	getNamespace (SqlNode node, SqlValidatorScope scope)

SqlValidatorNamespace	getNamespace (SqlIdentifier id, DelegatingScope scope)

void	handleOffsetFetch (SqlNode offset, SqlNode fetch)

SqlSelect	getInnerSelect (SqlNode node)

void	rewriteMerge (SqlMerge call)

SqlNode	rewriteUpdateToMerge (SqlUpdate updateCall, SqlNode selfJoinSrcExpr)

void	registerMatchRecognize (SqlValidatorScope parentScope, SqlValidatorScope usingScope, SqlMatchRecognize call, SqlNode enclosingNode, String alias, boolean forceNullable)

SqlNode	registerFrom (SqlValidatorScope parentScope, SqlValidatorScope usingScope, boolean register, final SqlNode node, SqlNode enclosingNode, String alias, SqlNodeList extendList, boolean forceNullable, final boolean lateral)

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

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

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

void	registerWith (SqlValidatorScope parentScope, SqlValidatorScope usingScope, SqlWith with, SqlNode enclosingNode, String alias, boolean forceNullable, boolean checkUpdate)

SqlNode	getAgg (SqlSelect select)

void	validateNodeFeature (SqlNode node)

void	registerSubQueries (SqlValidatorScope parentScope, SqlNode node)

void	registerOperandSubQueries (SqlValidatorScope parentScope, SqlCall call, int operandOrdinal)

void	validateLiteralAsDouble (SqlLiteral literal)

void	checkRollUpInUsing (SqlIdentifier identifier, SqlNode leftOrRight, SqlValidatorScope scope)

void	validateNoAggs (AggFinder aggFinder, SqlNode node, String clause)

RelDataType	validateUsingCol (SqlIdentifier id, SqlNode leftOrRight)

void	checkRollUpInSelectList (SqlSelect select)

void	checkRollUpInGroupBy (SqlSelect select)

void	checkRollUpInOrderBy (SqlSelect select)

void	checkRollUpInWindow (SqlWindow window, SqlValidatorScope scope)

void	checkRollUpInWindowDecl (SqlSelect select)

SqlNode	stripDot (SqlNode node)

void	checkRollUp (SqlNode grandParent, SqlNode parent, SqlNode current, SqlValidatorScope scope, String optionalClause)

void	checkRollUp (SqlNode grandParent, SqlNode parent, SqlNode current, SqlValidatorScope scope)

SqlWindow	getWindowInOver (SqlNode over)

Pair< String, String >	findTableColumnPair (SqlIdentifier identifier, SqlValidatorScope scope)

boolean	isRolledUpColumnAllowedInAgg (SqlIdentifier identifier, SqlValidatorScope scope, SqlCall aggCall, SqlNode parent)

boolean	isRolledUpColumn (SqlIdentifier identifier, SqlValidatorScope scope)

boolean	shouldCheckForRollUp (SqlNode from)

void	validateModality (SqlNode query)

SqlModality	deduceModality (SqlNode query)

boolean	hasSortedPrefix (SelectScope scope, SqlNodeList orderList)

boolean	isSortCompatible (SelectScope scope, SqlNode node, boolean descending)

void	validateGroupByItem (SqlSelect select, SqlNode groupByItem)

void	validateGroupByExpr (SqlNode groupByItem, SqlValidatorScope groupByScope)

void	validateOrderItem (SqlSelect select, SqlNode orderItem)

void	validateGroupItem (SqlValidatorScope groupScope, AggregatingSelectScope aggregatingScope, SqlNode groupItem)

void	validateGroupingSets (SqlValidatorScope groupScope, AggregatingSelectScope aggregatingScope, SqlCall groupItem)

void	validateExpr (SqlNode expr, SqlValidatorScope scope)

void	handleScalarSubQuery (SqlSelect parentSelect, SqlSelect selectItem, List< SqlNode > expandedSelectItems, Set< String > aliasList, List< Map.Entry< String, RelDataType >> fieldList)

void	checkConstraint (SqlValidatorTable validatorTable, SqlNode source, RelDataType targetRowType)

void	checkConstraint (SqlValidatorTable validatorTable, SqlUpdate update, RelDataType targetRowType)

void	checkFieldCount (SqlNode node, SqlValidatorTable table, List< ColumnStrategy > strategies, RelDataType targetRowTypeToValidate, RelDataType realTargetRowType, SqlNode source, RelDataType logicalSourceRowType, RelDataType logicalTargetRowType)

boolean	isValuesWithDefault (SqlNode source, int column)

boolean	isRowWithDefault (SqlNode operand, int column)

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

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

void	validateSnapshot (SqlNode node, SqlValidatorScope scope, SqlValidatorNamespace ns)

List< Map.Entry< String, RelDataType > >	validateMeasure (SqlMatchRecognize mr, MatchRecognizeScope scope, boolean allRows)

SqlNode	navigationInMeasure (SqlNode node, boolean allRows)

void	validateDefinitions (SqlMatchRecognize mr, MatchRecognizeScope scope)

SqlNode	navigationInDefine (SqlNode node, String alpha)

List< String >	getFieldOrigin (SqlNode sqlQuery, int i)

Static Private Member Functions
static SqlNode	expandExprFromJoin (SqlJoin join, SqlIdentifier identifier, SelectScope scope)

static SqlNode	expandCommonColumn (SqlSelect sqlSelect, SqlNode selectItem, SelectScope scope, SqlValidatorImpl validator)

static void	validateQualifiedCommonColumn (SqlJoin join, SqlIdentifier identifier, SelectScope scope, SqlValidatorImpl validator)

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

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

static SqlNode	stripOver (SqlNode node)

static String	alias (SqlNode item)

static boolean	isPhysicalNavigation (SqlKind kind)

static boolean	isLogicalNavigation (SqlKind kind)

static boolean	isAggregation (SqlKind kind)

static boolean	isRunningOrFinal (SqlKind kind)

static boolean	isSingleVarRequired (SqlKind kind)

Private Attributes
final SqlOperatorTable	opTab

final Map< IdPair< SqlSelect, Clause >, SqlValidatorScope >	clauseScopes = new HashMap<>()

TableScope	tableScope = null

final Set< SqlNode >	cursorSet = Sets.newIdentityHashSet()

int	nextGeneratedId

final RelDataType	booleanType

final Map< SqlNode, RelDataType >	nodeToTypeMap

final AggFinder	aggFinder

final AggFinder	aggOrOverFinder

final AggFinder	aggOrOverOrGroupFinder

final AggFinder	groupFinder

final AggFinder	overFinder

Config	config

final Map< SqlNode, SqlNode >	originalExprs = new HashMap<>()

SqlNode	top

boolean	validatingSqlMerge

boolean	inWindow

final SqlValidatorImpl.ValidationErrorFunction	validationErrorFunction

TypeCoercion	typeCoercion

Detailed Description

Default implementation of SqlValidator.

Definition at line 178 of file SqlValidatorImpl.java.

Constructor & Destructor Documentation

org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl	(	SqlOperatorTable	opTab,
		SqlValidatorCatalogReader	catalogReader,
		RelDataTypeFactory	typeFactory,
		Config	config
	)

inlineprotected

Creates a validator.

Parameters

opTab	Operator table
catalogReader	Catalog reader
typeFactory	Type factory
config	Config

Definition at line 299 of file SqlValidatorImpl.java.

                      {
     this.opTab = Objects.requireNonNull(opTab);
     this.catalogReader = Objects.requireNonNull(catalogReader);
     this.typeFactory = Objects.requireNonNull(typeFactory);
     this.config = Objects.requireNonNull(config);
 
     unknownType = typeFactory.createUnknownType();
     booleanType = typeFactory.createSqlType(SqlTypeName.BOOLEAN);
 
     final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
     aggFinder = new AggFinder(opTab, false, true, false, null, nameMatcher);
     aggOrOverFinder =
         new AggFinder(opTab, true, true, false, null, nameMatcher);
     overFinder = new AggFinder(opTab, true, false, false, aggOrOverFinder,
         nameMatcher);
     groupFinder = new AggFinder(opTab, false, false, true, null, nameMatcher);
     aggOrOverOrGroupFinder = new AggFinder(opTab, true, true, true, null,
         nameMatcher);
     // this.typeCoercion = config.typeCoercionFactory().create(typeFactory, this); // HEAVY.AI original
     this.typeCoercion = TypeCoercions.createHeavyDBTypeCoercion(typeFactory, this); // HEAVY.AI new
     if (config.typeCoercionRules() != null) {
       SqlTypeCoercionRule.THREAD_PROVIDERS.set(config.typeCoercionRules());
     }
   }

Here is the call graph for this function:

Member Function Documentation

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.addOrExpandField	(	List< SqlNode >	selectItems,
		Set< String >	aliases,
		List< Map.Entry< String, RelDataType >>	fields,
		boolean	includeSystemVars,
		SelectScope	scope,
		SqlIdentifier	id,
		RelDataTypeField	field
	)

inlineprivate

Definition at line 722 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.addToSelectList(), and org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar().

                                                                    {
     switch (field.getType().getStructKind()) {
     case PEEK_FIELDS:
     case PEEK_FIELDS_DEFAULT:
       final SqlNode starExp = id.plusStar();
       expandStar(
           selectItems,
           aliases,
           fields,
           includeSystemVars,
           scope,
           starExp);
       return true;
 
     default:
       addToSelectList(
           selectItems,
           aliases,
           fields,
           id,
           scope,
           includeSystemVars);
     }
 
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.addToSelectList	(	List< SqlNode >	list,
		Set< String >	aliases,
		List< Map.Entry< String, RelDataType >>	fieldList,
		SqlNode	exp,
		SelectScope	scope,
		final boolean	includeSystemVars
	)

inlineprotected

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

Definition at line 1984 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.alias(), and org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.addOrExpandField(), and org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar().

                                        {
     String alias = SqlValidatorUtil.getAlias(exp, -1);
     String uniqueAlias =
         SqlValidatorUtil.uniquify(
             alias, aliases, SqlValidatorUtil.EXPR_SUGGESTER);
     if (!Objects.equals(alias, uniqueAlias)) {
       exp = SqlValidatorUtil.addAlias(exp, uniqueAlias);
     }
     fieldList.add(Pair.of(uniqueAlias, deriveType(scope, exp)));
     list.add(exp);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static String org.apache.calcite.sql.validate.SqlValidatorImpl.alias ( SqlNode item )

inlinestaticprivate

Returns the alias of a "expr AS alias" expression.

Definition at line 5381 of file SqlValidatorImpl.java.

                                             {
     assert item instanceof SqlCall;
     assert item.getKind() == SqlKind.AS;
     final SqlIdentifier identifier = ((SqlCall) item).operand(1);
     return identifier.getSimple();
   }

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkConstraint	(	SqlValidatorTable	validatorTable,
		SqlNode	source,
		RelDataType	targetRowType
	)

inlineprivate

Validates insert values against the constraint of a modifiable view.

Parameters

validatorTable	Table that may wrap a ModifiableViewTable
source	The values being inserted
targetRowType	The target type for the view

Definition at line 4431 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

                                  {
     final ModifiableViewTable modifiableViewTable =
         validatorTable.unwrap(ModifiableViewTable.class);
     if (modifiableViewTable != null && source instanceof SqlCall) {
       final Table table = modifiableViewTable.unwrap(Table.class);
       final RelDataType tableRowType = table.getRowType(typeFactory);
       final List<RelDataTypeField> tableFields = tableRowType.getFieldList();
 
       // Get the mapping from column indexes of the underlying table
       // to the target columns and view constraints.
       final Map<Integer, RelDataTypeField> tableIndexToTargetField =
           SqlValidatorUtil.getIndexToFieldMap(tableFields, targetRowType);
       final Map<Integer, RexNode> projectMap =
           RelOptUtil.getColumnConstraints(modifiableViewTable, targetRowType, typeFactory);
 
       // Determine columns (indexed to the underlying table) that need
       // to be validated against the view constraint.
       final ImmutableBitSet targetColumns =
           ImmutableBitSet.of(tableIndexToTargetField.keySet());
       final ImmutableBitSet constrainedColumns =
           ImmutableBitSet.of(projectMap.keySet());
       final ImmutableBitSet constrainedTargetColumns =
           targetColumns.intersect(constrainedColumns);
 
       // Validate insert values against the view constraint.
       final List<SqlNode> values = ((SqlCall) source).getOperandList();
       for (final int colIndex : constrainedTargetColumns.asList()) {
         final String colName = tableFields.get(colIndex).getName();
         final RelDataTypeField targetField = tableIndexToTargetField.get(colIndex);
         for (SqlNode row : values) {
           final SqlCall call = (SqlCall) row;
           final SqlNode sourceValue = call.operand(targetField.getIndex());
           final ValidationError validationError =
               new ValidationError(sourceValue,
                   RESOURCE.viewConstraintNotSatisfied(colName,
                       Util.last(validatorTable.getQualifiedName())));
           RelOptUtil.validateValueAgainstConstraint(sourceValue,
               projectMap.get(colIndex), validationError);
         }
       }
     }
   }

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkConstraint	(	SqlValidatorTable	validatorTable,
		SqlUpdate	update,
		RelDataType	targetRowType
	)

inlineprivate

Validates updates against the constraint of a modifiable view.

Parameters

validatorTable	A SqlValidatorTable that may wrap a ModifiableViewTable
update	The UPDATE parse tree node
targetRowType	The target type

Definition at line 4485 of file SqlValidatorImpl.java.

References Integer, and org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

                                  {
     final ModifiableViewTable modifiableViewTable =
         validatorTable.unwrap(ModifiableViewTable.class);
     if (modifiableViewTable != null) {
       final Table table = modifiableViewTable.unwrap(Table.class);
       final RelDataType tableRowType = table.getRowType(typeFactory);
 
       final Map<Integer, RexNode> projectMap =
           RelOptUtil.getColumnConstraints(modifiableViewTable, targetRowType,
               typeFactory);
       final Map<String, Integer> nameToIndex =
           SqlValidatorUtil.mapNameToIndex(tableRowType.getFieldList());
 
       // Validate update values against the view constraint.
       final List<SqlNode> targets = update.getTargetColumnList().getList();
       final List<SqlNode> sources = update.getSourceExpressionList().getList();
       for (final Pair<SqlNode, SqlNode> column : Pair.zip(targets, sources)) {
         final String columnName = ((SqlIdentifier) column.left).getSimple();
         final Integer columnIndex = nameToIndex.get(columnName);
         if (projectMap.containsKey(columnIndex)) {
           final RexNode columnConstraint = projectMap.get(columnIndex);
           final ValidationError validationError =
               new ValidationError(column.right,
                   RESOURCE.viewConstraintNotSatisfied(columnName,
                       Util.last(validatorTable.getQualifiedName())));
           RelOptUtil.validateValueAgainstConstraint(column.right,
               columnConstraint, validationError);
         }
       }
     }
   }

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkFieldCount	(	SqlNode	node,
		SqlValidatorTable	table,
		List< ColumnStrategy >	strategies,
		RelDataType	targetRowTypeToValidate,
		RelDataType	realTargetRowType,
		SqlNode	source,
		RelDataType	logicalSourceRowType,
		RelDataType	logicalTargetRowType
	)

inlineprivate

Check the field count of sql insert source and target node row type.

Parameters

node	target table sql identifier
table	target table
strategies	column strategies of target table
targetRowTypeToValidate	row type to validate mainly for column strategies
realTargetRowType	target table row type exclusive virtual columns
source	source node
logicalSourceRowType	source node row type
logicalTargetRowType	logical target row type, contains only target columns if they are specified or if the sql dialect allows subset insert, make a subset of fields(start from the left first field) whose length is equals with the source row type fields number

Definition at line 4535 of file SqlValidatorImpl.java.

References field(), org.apache.calcite.sql.validate.SqlValidatorImpl.isValuesWithDefault(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert().

                                                                           {
     final int sourceFieldCount = logicalSourceRowType.getFieldCount();
     final int targetFieldCount = logicalTargetRowType.getFieldCount();
     final int targetRealFieldCount = realTargetRowType.getFieldCount();
     if (sourceFieldCount != targetFieldCount
         && sourceFieldCount != targetRealFieldCount) {
       // Allows the source row fields count to be equal with either
       // the logical or the real(excludes columns that can not insert into)
       // target row fields count.
       throw newValidationError(node,
           RESOURCE.unmatchInsertColumn(targetFieldCount, sourceFieldCount));
     }
     // Ensure that non-nullable fields are targeted.
     for (final RelDataTypeField field : table.getRowType().getFieldList()) {
       final RelDataTypeField targetField =
           targetRowTypeToValidate.getField(field.getName(), true, false);
       switch (strategies.get(field.getIndex())) {
       case NOT_NULLABLE:
         assert !field.getType().isNullable();
         if (targetField == null) {
           throw newValidationError(node,
               RESOURCE.columnNotNullable(field.getName()));
         }
         break;
       case NULLABLE:
         assert field.getType().isNullable();
         break;
       case VIRTUAL:
       case STORED:
         if (targetField != null
             && !isValuesWithDefault(source, targetField.getIndex())) {
           throw newValidationError(node,
               RESOURCE.insertIntoAlwaysGenerated(field.getName()));
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp	(	SqlNode	grandParent,
		SqlNode	parent,
		SqlNode	current,
		SqlValidatorScope	scope,
		String	optionalClause
	)

inlineprivate

Definition at line 3535 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInGroupBy(), org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInOrderBy(), org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInSelectList(), org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInWindow(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                                                             {
     current = stripAs(current);
     if (current instanceof SqlCall && !(current instanceof SqlSelect)) {
       // Validate OVER separately
       checkRollUpInWindow(getWindowInOver(current), scope);
       current = stripOver(current);
 
       List<SqlNode> children = ((SqlCall) stripAs(stripDot(current))).getOperandList();
       for (SqlNode child : children) {
         checkRollUp(parent, current, child, scope, optionalClause);
       }
     } else if (current instanceof SqlIdentifier) {
       SqlIdentifier id = (SqlIdentifier) current;
       if (!id.isStar() && isRolledUpColumn(id, scope)) {
         if (!isAggregation(parent.getKind())
             || !isRolledUpColumnAllowedInAgg(id, scope, (SqlCall) parent, grandParent)) {
           String context = optionalClause != null ? optionalClause : parent.getKind().toString();
           throw newValidationError(id,
               RESOURCE.rolledUpNotAllowed(deriveAlias(id, 0), context));
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp	(	SqlNode	grandParent,
		SqlNode	parent,
		SqlNode	current,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 3560 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp().

                                                                      {
     checkRollUp(grandParent, parent, current, scope, null);
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInGroupBy ( SqlSelect select )

inlineprivate

Definition at line 3492 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), and org.apache.calcite.sql.validate.SqlValidatorImpl.getGroupScope().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                       {
     SqlNodeList group = select.getGroup();
     if (group != null) {
       for (SqlNode node : group) {
         checkRollUp(null, select, node, getGroupScope(select), "GROUP BY");
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInOrderBy ( SqlSelect select )

inlineprivate

Definition at line 3501 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), and org.apache.calcite.sql.validate.SqlValidatorImpl.getOrderScope().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                       {
     SqlNodeList orderList = select.getOrderList();
     if (orderList != null) {
       for (SqlNode node : orderList) {
         checkRollUp(null, select, node, getOrderScope(select), "ORDER BY");
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInSelectList ( SqlSelect select )

inlineprivate

Definition at line 3485 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), and org.apache.calcite.sql.validate.SqlValidatorImpl.getSelectScope().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                          {
     SqlValidatorScope scope = getSelectScope(select);
     for (SqlNode item : select.getSelectList()) {
       checkRollUp(null, select, item, scope);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInUsing	(	SqlIdentifier	identifier,
		SqlNode	leftOrRight,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 3219 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin().

                                                     {
     SqlValidatorNamespace namespace = getNamespace(leftOrRight, scope);
     if (namespace != null) {
       SqlValidatorTable sqlValidatorTable = namespace.getTable();
       if (sqlValidatorTable != null) {
         Table table = sqlValidatorTable.unwrap(Table.class);
         String column = Util.last(identifier.names);
 
         if (table.isRolledUp(column)) {
           throw newValidationError(identifier,
               RESOURCE.rolledUpNotAllowed(column, "USING"));
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInWindow	(	SqlWindow	window,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 3510 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), and org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInWindowDecl().

                                                                               {
     if (window != null) {
       for (SqlNode node : window.getPartitionList()) {
         checkRollUp(null, window, node, scope, "PARTITION BY");
       }
 
       for (SqlNode node : window.getOrderList()) {
         checkRollUp(null, window, node, scope, "ORDER BY");
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInWindowDecl ( SqlSelect select )

inlineprivate

Definition at line 3522 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInWindow(), and org.apache.calcite.sql.validate.SqlValidatorImpl.getSelectScope().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                          {
     for (SqlNode decl : select.getWindowList()) {
       checkRollUpInWindow((SqlWindow) decl, getSelectScope(select));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.checkTypeAssignment	(	SqlValidatorScope	sourceScope,
		SqlValidatorTable	table,
		RelDataType	sourceRowType,
		RelDataType	targetRowType,
		final SqlNode	query
	)

inlineprotected

Checks the type assignment of an INSERT or UPDATE query.

Skip the virtual columns(can not insert into) type assignment check if the source fields count equals with the real target table fields count, see how checkFieldCount was used.

Parameters

sourceScope	Scope of query source which is used to infer node type
table	Target table
sourceRowType	Source row type
targetRowType	Target row type, it should either contain all the virtual columns (can not insert into) or exclude all the virtual columns
query	The query

Definition at line 4645 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.config(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNthExpr(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

                            {
     // NOTE jvs 23-Feb-2006: subclasses may allow for extra targets
     // representing system-maintained columns, so stop after all sources
     // matched
     boolean isUpdateModifiableViewTable = false;
     if (query instanceof SqlUpdate) {
       final SqlNodeList targetColumnList = ((SqlUpdate) query).getTargetColumnList();
       if (targetColumnList != null) {
         final int targetColumnCnt = targetColumnList.size();
         targetRowType = SqlTypeUtil.extractLastNFields(typeFactory, targetRowType,
             targetColumnCnt);
         sourceRowType = SqlTypeUtil.extractLastNFields(typeFactory, sourceRowType,
             targetColumnCnt);
       }
       isUpdateModifiableViewTable = table.unwrap(ModifiableViewTable.class) != null;
     }
     if (SqlTypeUtil.equalAsStructSansNullability(typeFactory,
         sourceRowType,
         targetRowType,
         null)) {
       // Returns early if source and target row type equals sans nullability.
       return;
     }
     if (config.typeCoercionEnabled() && !isUpdateModifiableViewTable) {
       // Try type coercion first if implicit type coercion is allowed.
       boolean coerced = typeCoercion.querySourceCoercion(sourceScope,
           sourceRowType,
           targetRowType,
           query);
       if (coerced) {
         return;
       }
     }
 
     // Fall back to default behavior: compare the type families.
     List<RelDataTypeField> sourceFields = sourceRowType.getFieldList();
     List<RelDataTypeField> targetFields = targetRowType.getFieldList();
     final int sourceCount = sourceFields.size();
     for (int i = 0; i < sourceCount; ++i) {
       RelDataType sourceType = sourceFields.get(i).getType();
       RelDataType targetType = targetFields.get(i).getType();
       if (!SqlTypeUtil.canAssignFrom(targetType, sourceType)) {
         SqlNode node = getNthExpr(query, i, sourceCount);
         if (node instanceof SqlDynamicParam) {
           continue;
         }
         String targetTypeString;
         String sourceTypeString;
         if (SqlTypeUtil.areCharacterSetsMismatched(
             sourceType,
             targetType)) {
           sourceTypeString = sourceType.getFullTypeString();
           targetTypeString = targetType.getFullTypeString();
         } else {
           sourceTypeString = sourceType.toString();
           targetTypeString = targetType.toString();
         }
         throw newValidationError(node,
             RESOURCE.typeNotAssignable(
                 targetFields.get(i).getName(), targetTypeString,
                 sourceFields.get(i).getName(), sourceTypeString));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Config org.apache.calcite.sql.validate.SqlValidatorImpl.config ( )

inline

Definition at line 3915 of file SqlValidatorImpl.java.

                          {
     return this.config;
   }

Here is the caller graph for this function:

MatchRecognizeNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.createMatchRecognizeNameSpace	(	SqlMatchRecognize	call,
		SqlNode	enclosingNode
	)

inlineprotected

Definition at line 2037 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerMatchRecognize().

                              {
     return new MatchRecognizeNamespace(this, call, enclosingNode);
   }

Here is the caller graph for this function:

SelectNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.createSelectNamespace	(	SqlSelect	select,
		SqlNode	enclosingNode
	)

inlineprotected

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

Parameters

select	Select node
enclosingNode	Enclosing node

Returns: Select namespace

Definition at line 2463 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.declareCursor(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

                              {
     return new SelectNamespace(this, select, enclosingNode);
   }

Here is the caller graph for this function:

SetopNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.createSetopNamespace	(	SqlCall	call,
		SqlNode	enclosingNode
	)

inlineprotected

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

Definition at line 2478 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerSetop().

                              {
     return new SetopNamespace(this, call, enclosingNode);
   }

Here is the caller graph for this function:

SqlSelect org.apache.calcite.sql.validate.SqlValidatorImpl.createSourceSelectForDelete ( SqlDelete call )

inlineprotected

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

Definition at line 1637 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites().

                                                                   {
     final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
     selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
     SqlNode sourceTable = call.getTargetTable();
     if (call.getAlias() != null) {
       sourceTable =
           SqlValidatorUtil.addAlias(
               sourceTable,
               call.getAlias().getSimple());
     }
     return new SqlSelect(SqlParserPos.ZERO, null, selectList, sourceTable,
         call.getCondition(), null, null, null, null, null, null, null);
   }

Here is the caller graph for this function:

SqlSelect org.apache.calcite.sql.validate.SqlValidatorImpl.createSourceSelectForUpdate ( SqlUpdate call )

inlineprotected

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

Definition at line 1608 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.alias().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites().

                                                                   {
     final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
     selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
     int ordinal = 0;
     for (SqlNode exp : call.getSourceExpressionList()) {
       // Force unique aliases to avoid a duplicate for Y with
       // SET X=Y
       String alias = SqlUtil.deriveAliasFromOrdinal(ordinal);
       selectList.add(SqlValidatorUtil.addAlias(exp, alias));
       ++ordinal;
     }
     SqlNode sourceTable = call.getTargetTable();
     if (call.getAlias() != null) {
       sourceTable =
           SqlValidatorUtil.addAlias(
               sourceTable,
               call.getAlias().getSimple());
     }
     return new SqlSelect(SqlParserPos.ZERO, null, selectList, sourceTable,
         call.getCondition(), null, null, null, null, null, null, null);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.createTargetRowType	(	SqlValidatorTable	table,
		SqlNodeList	targetColumnList,
		boolean	append
	)

inlineprotected

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

Definition at line 4316 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.catalogReader, org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

                       {
     RelDataType baseRowType = table.getRowType();
     if (targetColumnList == null) {
       return baseRowType;
     }
     List<RelDataTypeField> targetFields = baseRowType.getFieldList();
     final List<Map.Entry<String, RelDataType>> fields = new ArrayList<>();
     if (append) {
       for (RelDataTypeField targetField : targetFields) {
         fields.add(
             Pair.of(SqlUtil.deriveAliasFromOrdinal(fields.size()),
                 targetField.getType()));
       }
     }
     final Set<Integer> assignedFields = new HashSet<>();
     final RelOptTable relOptTable = table instanceof RelOptTable
         ? ((RelOptTable) table) : null;
     for (SqlNode node : targetColumnList) {
       SqlIdentifier id = (SqlIdentifier) node;
       RelDataTypeField targetField =
           SqlValidatorUtil.getTargetField(
               baseRowType, typeFactory, id, catalogReader, relOptTable);
       if (targetField == null) {
         throw newValidationError(id,
             RESOURCE.unknownTargetColumn(id.toString()));
       }
       if (!assignedFields.add(targetField.getIndex())) {
         throw newValidationError(id,
             RESOURCE.duplicateTargetColumn(targetField.getName()));
       }
       fields.add(targetField);
     }
     return typeFactory.createStructType(fields);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.declareCursor	(	SqlSelect	select,
		SqlValidatorScope	parentScope
	)

inline

Definition at line 373 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.alias(), org.apache.calcite.sql.validate.SqlValidatorImpl.createSelectNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.CURSOR, org.apache.calcite.sql.validate.SqlValidatorImpl.deriveAlias(), org.apache.calcite.sql.validate.SqlValidatorImpl.nextGeneratedId, and org.apache.calcite.sql.validate.SqlValidatorImpl.registerNamespace().

                                                                              {
     cursorSet.add(select);
 
     // add the cursor to a map that maps the cursor to its select based on
     // the position of the cursor relative to other cursors in that call
     FunctionParamInfo funcParamInfo = functionCallStack.peek();
     Map<Integer, SqlSelect> cursorMap = funcParamInfo.cursorPosToSelectMap;
     int numCursors = cursorMap.size();
     cursorMap.put(numCursors, select);
 
     // create a namespace associated with the result of the select
     // that is the argument to the cursor constructor; register it
     // with a scope corresponding to the cursor
     SelectScope cursorScope = new SelectScope(parentScope, null, select);
     clauseScopes.put(IdPair.of(select, Clause.CURSOR), cursorScope);
     final SelectNamespace selectNs = createSelectNamespace(select, select);
     String alias = deriveAlias(select, nextGeneratedId++);
     registerNamespace(cursorScope, alias, selectNs, false);
   }

Here is the call graph for this function:

SqlModality org.apache.calcite.sql.validate.SqlValidatorImpl.deduceModality ( SqlNode query )

inlineprivate

Return the intended modality of a SELECT or set-op.

Definition at line 3677 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateModality().

                                                     {
     if (query instanceof SqlSelect) {
       SqlSelect select = (SqlSelect) query;
       return select.getModifierNode(SqlSelectKeyword.STREAM) != null
           ? SqlModality.STREAM
           : SqlModality.RELATION;
     } else if (query.getKind() == SqlKind.VALUES) {
       return SqlModality.RELATION;
     } else {
       assert query.isA(SqlKind.SET_QUERY);
       final SqlCall call = (SqlCall) query;
       return deduceModality(call.getOperandList().get(0));
     }
   }

Here is the caller graph for this function:

String org.apache.calcite.sql.validate.SqlValidatorImpl.deriveAlias	(	SqlNode	node,
		int	ordinal
	)

inline

Definition at line 2002 of file SqlValidatorImpl.java.

                    {
     return SqlValidatorUtil.getAlias(node, ordinal);
   }

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.deriveConstructorType	(	SqlValidatorScope	scope,
		SqlCall	call,
		SqlFunction	unresolvedConstructor,
		SqlFunction	resolvedConstructor,
		List< RelDataType >	argTypes
	)

inline

Definition at line 1790 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.config(), org.apache.calcite.sql.validate.SqlValidatorImpl.handleUnresolvedFunction(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and run_benchmark_import.type.

                                   {
     SqlIdentifier sqlIdentifier = unresolvedConstructor.getSqlIdentifier();
     assert sqlIdentifier != null;
     RelDataType type = catalogReader.getNamedType(sqlIdentifier);
     if (type == null) {
       // TODO jvs 12-Feb-2005:  proper type name formatting
       throw newValidationError(sqlIdentifier,
           RESOURCE.unknownDatatypeName(sqlIdentifier.toString()));
     }
 
     if (resolvedConstructor == null) {
       if (call.operandCount() > 0) {
         // This is not a default constructor invocation, and
         // no user-defined constructor could be found
         throw handleUnresolvedFunction(call, unresolvedConstructor, argTypes,
             null);
       }
     } else {
       SqlCall testCall =
           resolvedConstructor.createCall(
               call.getParserPosition(),
               call.getOperandList());
       RelDataType returnType =
           resolvedConstructor.validateOperands(
               this,
               scope,
               testCall);
       assert type == returnType;
     }
 
     if (config.identifierExpansion()) {
       if (resolvedConstructor != null) {
         ((SqlBasicCall) call).setOperator(resolvedConstructor);
       } else {
         // fake a fully-qualified call to the default constructor
         ((SqlBasicCall) call).setOperator(
             new SqlFunction(
                 type.getSqlIdentifier(),
                 ReturnTypes.explicit(type),
                 null,
                 null,
                 null,
                 SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR));
       }
     }
     return type;
   }

Here is the call graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType	(	SqlValidatorScope	scope,
		SqlNode	expr
	)

inline

Definition at line 1756 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.deriveTypeImpl(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType(), and run_benchmark_import.type.

                     {
     Objects.requireNonNull(scope);
     Objects.requireNonNull(expr);
 
     // if we already know the type, no need to re-derive
     RelDataType type = nodeToTypeMap.get(expr);
     if (type != null) {
       return type;
     }
     final SqlValidatorNamespace ns = getNamespace(expr);
     if (ns != null) {
       return ns.getType();
     }
     type = deriveTypeImpl(scope, expr);
     Preconditions.checkArgument(
         type != null,
         "SqlValidator.deriveTypeInternal returned null");
     setValidatedNodeType(expr, type);
     return type;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.deriveTypeImpl	(	SqlValidatorScope	scope,
		SqlNode	operand
	)

inlinepackage

Derives the type of a node, never null.

Definition at line 1782 of file SqlValidatorImpl.java.

References run_benchmark_import.type.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), and org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectItem().

                        {
     DeriveTypeVisitor v = new DeriveTypeVisitor(scope);
     final RelDataType type = operand.accept(v);
     return Objects.requireNonNull(scope.nullifyType(operand, type));
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.expand	(	SqlNode	expr,
		SqlValidatorScope	scope
	)

inline

Definition at line 5524 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.setOriginal().

                                                                {
     final Expander expander = new Expander(this, scope);
     SqlNode newExpr = expr.accept(expander);
     if (expr != newExpr) {
       setOriginal(newExpr, expr);
     }
     return newExpr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.expandCommonColumn	(	SqlSelect	sqlSelect,
		SqlNode	selectItem,
		SelectScope	scope,
		SqlValidatorImpl	validator
	)

inlinestaticprivate

Definition at line 543 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.config, org.apache.calcite.sql.validate.SqlValidatorImpl.expandExprFromJoin(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateQualifiedCommonColumn().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.SelectExpander.visit(), and org.apache.calcite.sql.validate.SqlValidatorImpl.ExtendedExpander.visit().

                                                                          {
     if (!(selectItem instanceof SqlIdentifier)) {
       return selectItem;
     }
 
     final SqlNode from = sqlSelect.getFrom();
     if (!(from instanceof SqlJoin)) {
       return selectItem;
     }
 
     final SqlIdentifier identifier = (SqlIdentifier) selectItem;
     if (!identifier.isSimple()) {
       if (!validator.config().sqlConformance().allowQualifyingCommonColumn()) {
         validateQualifiedCommonColumn((SqlJoin) from, identifier, scope, validator);
       }
       return selectItem;
     }
 
     return expandExprFromJoin((SqlJoin) from, identifier, scope);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.expandExprFromJoin	(	SqlJoin	join,
		SqlIdentifier	identifier,
		SelectScope	scope
	)

inlinestaticprivate

Definition at line 476 of file SqlValidatorImpl.java.

References Fragmenter_Namespace.indexOf(), and setup.name.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandCommonColumn().

                          {
     if (join.getConditionType() != JoinConditionType.USING) {
       return identifier;
     }
 
     for (SqlNode node : (SqlNodeList) join.getCondition()) {
       final String name = ((SqlIdentifier) node).getSimple();
       if (identifier.getSimple().equals(name)) {
         final List<SqlNode> qualifiedNode = new ArrayList<>();
         for (ScopeChild child : scope.children) {
           if (child.namespace.getRowType()
               .getFieldNames().indexOf(name) >= 0) {
             final SqlIdentifier exp =
                 new SqlIdentifier(
                     ImmutableList.of(child.name, name),
                     identifier.getParserPosition());
             qualifiedNode.add(exp);
           }
         }
 
         assert qualifiedNode.size() == 2;
         final SqlNode finalNode =
             SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO,
                 SqlStdOperatorTable.COALESCE.createCall(SqlParserPos.ZERO,
                     qualifiedNode.get(0),
                     qualifiedNode.get(1)),
                 new SqlIdentifier(name, SqlParserPos.ZERO));
         return finalNode;
       }
     }
 
     // Only need to try to expand the expr from the left input of join
     // since it is always left-deep join.
     final SqlNode node = join.getLeft();
     if (node instanceof SqlJoin) {
       return expandExprFromJoin((SqlJoin) node, identifier, scope);
     } else {
       return identifier;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.expandGroupByOrHavingExpr	(	SqlNode	expr,
		SqlValidatorScope	scope,
		SqlSelect	select,
		boolean	havingExpression
	)

inline

Definition at line 5533 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.setOriginal().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateHavingClause().

                                                                            {
     final Expander expander = new ExtendedExpander(this, scope, select, expr,
         havingExpression);
     SqlNode newExpr = expr.accept(expander);
     if (expr != newExpr) {
       setOriginal(newExpr, expr);
     }
     return newExpr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.expandOrderExpr	(	SqlSelect	select,
		SqlNode	orderExpr
	)

inline

Definition at line 4009 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.getOrderScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.inferUnknownTypes(), org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType(), run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType.

                                                                       {
     final SqlNode newSqlNode =
         new OrderExpressionExpander(select, orderExpr).go();
     if (newSqlNode != orderExpr) {
       final SqlValidatorScope scope = getOrderScope(select);
       inferUnknownTypes(unknownType, scope, newSqlNode);
       final RelDataType type = deriveType(scope, newSqlNode);
       setValidatedNodeType(newSqlNode, type);
     }
     return newSqlNode;
   }

Here is the call graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectExpr	(	SqlNode	expr,
		SelectScope	scope,
		SqlSelect	select
	)

inline

Definition at line 5514 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.setOriginal().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectItem().

                                            {
     final Expander expander = new SelectExpander(this, scope, select);
     final SqlNode newExpr = expr.accept(expander);
     if (expr != newExpr) {
       setOriginal(newExpr, expr);
     }
     return newExpr;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectItem	(	final SqlNode	selectItem,
		SqlSelect	select,
		RelDataType	targetType,
		List< SqlNode >	selectItems,
		Set< String >	aliases,
		List< Map.Entry< String, RelDataType >>	fields,
		final boolean	includeSystemVars
	)

inlineprivate

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	Set of aliases
fields	List of field names and types, in alias order
includeSystemVars	If true include system vars in lists

Returns: Whether the node was expanded

Definition at line 424 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList().

                                        {
     final SelectScope scope = (SelectScope) getWhereScope(select);
     if (expandStar(selectItems, aliases, fields, includeSystemVars, scope,
         selectItem)) {
       return true;
     }
 
     // Expand the select item: fully-qualify columns, and convert
     // parentheses-free functions such as LOCALTIME into explicit function
     // calls.
     SqlNode expanded = expandSelectExpr(selectItem, scope, select);
     final String alias =
         deriveAlias(
             selectItem,
             aliases.size());
 
     // If expansion has altered the natural alias, supply an explicit 'AS'.
     final SqlValidatorScope selectScope = getSelectScope(select);
     if (expanded != selectItem) {
       String newAlias =
           deriveAlias(
               expanded,
               aliases.size());
       if (!newAlias.equals(alias)) {
         expanded =
             SqlStdOperatorTable.AS.createCall(
                 selectItem.getParserPosition(),
                 expanded,
                 new SqlIdentifier(alias, SqlParserPos.ZERO));
         deriveTypeImpl(selectScope, expanded);
       }
     }
 
     selectItems.add(expanded);
     aliases.add(alias);
 
     if (expanded != null) {
       inferUnknownTypes(targetType, scope, expanded);
     }
     final RelDataType type = deriveType(selectScope, expanded);
     setValidatedNodeType(expanded, type);
     fields.add(Pair.of(alias, type));
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNodeList org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar	(	SqlNodeList	selectList,
		SqlSelect	select,
		boolean	includeSystemVars
	)

inline

Definition at line 350 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectItem(), org.apache.calcite.sql.validate.SqlValidatorImpl.getRawSelectScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeTypeIfKnown(), and org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.addOrExpandField(), org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectItem(), and org.apache.calcite.sql.validate.SqlValidatorImpl.OrderExpressionExpander.nthSelectItem().

                                  {
     final List<SqlNode> list = new ArrayList<>();
     final List<Map.Entry<String, RelDataType>> types = new ArrayList<>();
     for (int i = 0; i < selectList.size(); i++) {
       final SqlNode selectItem = selectList.get(i);
       final RelDataType originalType = getValidatedNodeTypeIfKnown(selectItem);
       expandSelectItem(
           selectItem,
           select,
           Util.first(originalType, unknownType),
           list,
           catalogReader.nameMatcher().createSet(),
           types,
           includeSystemVars);
     }
     getRawSelectScope(select).setExpandedSelectList(list);
     return new SqlNodeList(list, SqlParserPos.ZERO);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar	(	List< SqlNode >	selectItems,
		Set< String >	aliases,
		List< Map.Entry< String, RelDataType >>	fields,
		boolean	includeSystemVars,
		SelectScope	scope,
		SqlNode	node
	)

inlineprivate

Definition at line 592 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.addOrExpandField(), org.apache.calcite.sql.validate.SqlValidatorImpl.addToSelectList(), field(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.isRolledUpColumn(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

                                        {
     if (!(node instanceof SqlIdentifier)) {
       return false;
     }
     final SqlIdentifier identifier = (SqlIdentifier) node;
     if (!identifier.isStar()) {
       return false;
     }
     final SqlParserPos startPosition = identifier.getParserPosition();
     switch (identifier.names.size()) {
     case 1:
       boolean hasDynamicStruct = false;
       for (ScopeChild child : scope.children) {
         final int before = fields.size();
         if (child.namespace.getRowType().isDynamicStruct()) {
           hasDynamicStruct = true;
           // don't expand star if the underneath table is dynamic.
           // Treat this star as a special field in validation/conversion and
           // wait until execution time to expand this star.
           final SqlNode exp =
               new SqlIdentifier(
                   ImmutableList.of(child.name,
                       DynamicRecordType.DYNAMIC_STAR_PREFIX),
                   startPosition);
           addToSelectList(
                selectItems,
                aliases,
                fields,
                exp,
                scope,
                includeSystemVars);
         } else {
           final SqlNode from = child.namespace.getNode();
           final SqlValidatorNamespace fromNs = getNamespace(from, scope);
           assert fromNs != null;
           final RelDataType rowType = fromNs.getRowType();
           for (RelDataTypeField field : rowType.getFieldList()) {
             String columnName = field.getName();
 
             // TODO: do real implicit collation here
             final SqlIdentifier exp =
                 new SqlIdentifier(
                     ImmutableList.of(child.name, columnName),
                     startPosition);
             // Don't add expanded rolled up columns
             if (!isRolledUpColumn(exp, scope)) {
               addOrExpandField(
                       selectItems,
                       aliases,
                       fields,
                       includeSystemVars,
                       scope,
                       exp,
                       field);
             }
           }
         }
         if (child.nullable) {
           for (int i = before; i < fields.size(); i++) {
             final Map.Entry<String, RelDataType> entry = fields.get(i);
             final RelDataType type = entry.getValue();
             if (!type.isNullable()) {
               fields.set(i,
                   Pair.of(entry.getKey(),
                       typeFactory.createTypeWithNullability(type, true)));
             }
           }
         }
       }
       // If NATURAL JOIN or USING is present, move key fields to the front of
       // the list, per standard SQL. Disabled if there are dynamic fields.
       if (!hasDynamicStruct || Bug.CALCITE_2400_FIXED) {
         new Permute(scope.getNode().getFrom(), 0).permute(selectItems, fields);
       }
       return true;
 
     default:
       final SqlIdentifier prefixId = identifier.skipLast(1);
       final SqlValidatorScope.ResolvedImpl resolved =
           new SqlValidatorScope.ResolvedImpl();
       final SqlNameMatcher nameMatcher =
           scope.validator.catalogReader.nameMatcher();
       scope.resolve(prefixId.names, nameMatcher, true, resolved);
       if (resolved.count() == 0) {
         // e.g. "select s.t.* from e"
         // or "select r.* from e"
         throw newValidationError(prefixId,
             RESOURCE.unknownIdentifier(prefixId.toString()));
       }
       final RelDataType rowType = resolved.only().rowType();
       if (rowType.isDynamicStruct()) {
         // don't expand star if the underneath table is dynamic.
         addToSelectList(
             selectItems,
             aliases,
             fields,
             prefixId.plus(DynamicRecordType.DYNAMIC_STAR_PREFIX, startPosition),
             scope,
             includeSystemVars);
       } else if (rowType.isStruct()) {
         for (RelDataTypeField field : rowType.getFieldList()) {
           String columnName = field.getName();
 
           // TODO: do real implicit collation here
           addOrExpandField(
               selectItems,
               aliases,
               fields,
               includeSystemVars,
               scope,
               prefixId.plus(columnName, startPosition),
               field);
         }
       } else {
         throw newValidationError(prefixId, RESOURCE.starRequiresRecordType());
       }
       return true;
     }
   }

Here is the call graph for this function:

static void org.apache.calcite.sql.validate.SqlValidatorImpl.findAllValidFunctionNames	(	List< String >	names,
		SqlValidator	validator,
		Collection< SqlMoniker >	result,
		SqlParserPos	pos
	)

inlinestaticprivate

Definition at line 987 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupNameCompletionHints().

                         {
     // a function name can only be 1 part
     if (names.size() > 1) {
       return;
     }
     for (SqlOperator op : validator.getOperatorTable().getOperatorList()) {
       SqlIdentifier curOpId =
           new SqlIdentifier(
               op.getName(),
               pos);
 
       final SqlCall call = validator.makeNullaryCall(curOpId);
       if (call != null) {
         result.add(
             new SqlMonikerImpl(
                 op.getName(),
                 SqlMonikerType.FUNCTION));
       } else {
         if ((op.getSyntax() == SqlSyntax.FUNCTION)
             || (op.getSyntax() == SqlSyntax.PREFIX)) {
           if (op.getOperandTypeChecker() != null) {
             String sig = op.getAllowedSignatures();
             sig = sig.replace("'", "");
             result.add(
                 new SqlMonikerImpl(
                     sig,
                     SqlMonikerType.FUNCTION));
             continue;
           }
           result.add(
               new SqlMonikerImpl(
                   op.getName(),
                   SqlMonikerType.FUNCTION));
         }
       }
     }
   }

Here is the caller graph for this function:

static void org.apache.calcite.sql.validate.SqlValidatorImpl.findAllValidUdfNames	(	List< String >	names,
		SqlValidator	validator,
		Collection< SqlMoniker >	result
	)

inlinestaticprivate

Definition at line 971 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupNameCompletionHints().

                                      {
     final List<SqlMoniker> objNames = new ArrayList<>();
     SqlValidatorUtil.getSchemaObjectMonikers(
         validator.getCatalogReader(),
         names,
         objNames);
     for (SqlMoniker objName : objNames) {
       if (objName.getType() == SqlMonikerType.FUNCTION) {
         result.add(objName);
       }
     }
   }

Here is the caller graph for this function:

Pair<String, String> org.apache.calcite.sql.validate.SqlValidatorImpl.findTableColumnPair	(	SqlIdentifier	identifier,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 3586 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.makeNullaryCall().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isRolledUpColumn(), and org.apache.calcite.sql.validate.SqlValidatorImpl.isRolledUpColumnAllowedInAgg().

                                {
     final SqlCall call = makeNullaryCall(identifier);
     if (call != null) {
       return null;
     }
     SqlQualified qualified = scope.fullyQualify(identifier);
     List<String> names = qualified.identifier.names;
 
     if (names.size() < 2) {
       return null;
     }
 
     return new Pair<>(names.get(names.size() - 2), Util.last(names));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.getAgg ( SqlSelect select )

inlineprivate

If there is at least one call to an aggregate function, returns the first.

Definition at line 2942 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getRawSelectScope().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getAggregate().

                                            {
     final SelectScope selectScope = getRawSelectScope(select);
     if (selectScope != null) {
       final List<SqlNode> selectList = selectScope.getExpandedSelectList();
       if (selectList != null) {
         return aggFinder.findAgg(selectList);
       }
     }
     return aggFinder.findAgg(select.getSelectList());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.getAggregate ( SqlSelect select )

inlineprotected

Returns the parse tree node (GROUP BY, HAVING, or an aggregate function call) that causes

select

to be an aggregate query, or null if it is not an aggregate query.

The node is useful context for error messages, but you cannot assume that the node is the only aggregate function.

Definition at line 2928 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getAgg().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregate(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateModality().

                                                    {
     SqlNode node = select.getGroup();
     if (node != null) {
       return node;
     }
     node = select.getHaving();
     if (node != null) {
       return node;
     }
     return getAgg(select);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlValidatorCatalogReader org.apache.calcite.sql.validate.SqlValidatorImpl.getCatalogReader ( )

inline

Definition at line 334 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.catalogReader.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeTypeIfKnown(), and org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFromHints().

                                                       {
     return catalogReader;
   }

Here is the caller graph for this function:

SqlConformance org.apache.calcite.sql.validate.SqlValidatorImpl.getConformance ( )

inline

Definition at line 330 of file SqlValidatorImpl.java.

                                          {
     return config.sqlConformance();
   }

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getCursorScope ( SqlSelect select )

inline

Definition at line 1108 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.CURSOR.

                                                             {
     return clauseScopes.get(IdPair.of(select, Clause.CURSOR));
   }

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getEmptyScope ( )

inline

Definition at line 1104 of file SqlValidatorImpl.java.

                                            {
     return new EmptyScope(this);
   }

List<String> org.apache.calcite.sql.validate.SqlValidatorImpl.getFieldOrigin	(	SqlNode	sqlQuery,
		int	i
	)

inlineprivate

Definition at line 5564 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getRawSelectScope(), and setup.name.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getFieldOrigins().

                                                                {
     if (sqlQuery instanceof SqlSelect) {
       SqlSelect sqlSelect = (SqlSelect) sqlQuery;
       final SelectScope scope = getRawSelectScope(sqlSelect);
       final List<SqlNode> selectList = scope.getExpandedSelectList();
       final SqlNode selectItem = stripAs(selectList.get(i));
       if (selectItem instanceof SqlIdentifier) {
         final SqlQualified qualified =
             scope.fullyQualify((SqlIdentifier) selectItem);
         SqlValidatorNamespace namespace = qualified.namespace;
         final SqlValidatorTable table = namespace.getTable();
         if (table == null) {
           return null;
         }
         final List<String> origin =
             new ArrayList<>(table.getQualifiedName());
         for (String name : qualified.suffix()) {
           namespace = namespace.lookupChild(name);
           if (namespace == null) {
             return null;
           }
           origin.add(name);
         }
         return origin;
       }
       return null;
     } else if (sqlQuery instanceof SqlOrderBy) {
       return getFieldOrigin(((SqlOrderBy) sqlQuery).query, i);
     } else {
       return null;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

List<List<String> > org.apache.calcite.sql.validate.SqlValidatorImpl.getFieldOrigins ( SqlNode sqlQuery )

inline

Definition at line 5548 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getFieldOrigin(), and org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType().

                                                               {
     if (sqlQuery instanceof SqlExplain) {
       return Collections.emptyList();
     }
     final RelDataType rowType = getValidatedNodeType(sqlQuery);
     final int fieldCount = rowType.getFieldCount();
     if (!sqlQuery.isA(SqlKind.QUERY)) {
       return Collections.nCopies(fieldCount, null);
     }
     final List<List<String>> list = new ArrayList<>();
     for (int i = 0; i < fieldCount; i++) {
       list.add(getFieldOrigin(sqlQuery, i));
     }
     return ImmutableNullableList.copyOf(list);
   }

Here is the call graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getFromScope ( SqlSelect select )

inline

Definition at line 1138 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWindowClause().

                                                           {
     return scopes.get(select);
   }

Here is the caller graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getGroupScope ( SqlSelect select )

inline

Definition at line 1133 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.GROUP_BY.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInGroupBy(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupByItem(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause().

                                                            {
     // Yes, it's the same as getWhereScope
     return clauseScopes.get(IdPair.of(select, Clause.GROUP_BY));
   }

Here is the caller graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getHavingScope ( SqlSelect select )

inline

Definition at line 1128 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.SELECT.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                             {
     // Yes, it's the same as getSelectScope
     return clauseScopes.get(IdPair.of(select, Clause.SELECT));
   }

Here is the caller graph for this function:

SqlSelect org.apache.calcite.sql.validate.SqlValidatorImpl.getInnerSelect ( SqlNode node )

inlineprivate

Definition at line 1434 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites().

                                                  {
     for (;;) {
       if (node instanceof SqlSelect) {
         return (SqlSelect) node;
       } else if (node instanceof SqlOrderBy) {
         node = ((SqlOrderBy) node).query;
       } else if (node instanceof SqlWith) {
         node = ((SqlWith) node).body;
       } else {
         return null;
       }
     }
   }

Here is the caller graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getJoinScope ( SqlNode node )

inline

Definition at line 1150 of file SqlValidatorImpl.java.

                                                       {
     return scopes.get(stripAs(node));
   }

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getLogicalSourceRowType	(	RelDataType	sourceRowType,
		SqlInsert	insert
	)

inlineprotected

Definition at line 4625 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getLogicalTargetRowType(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert().

                         {
     return sourceRowType;
   }

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getLogicalTargetRowType	(	RelDataType	targetRowType,
		SqlInsert	insert
	)

inlineprotected

Definition at line 4601 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getLogicalSourceRowType(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateNamespace().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert().

                         {
     if (insert.getTargetColumnList() == null
         && this.config.sqlConformance().isInsertSubsetColumnsAllowed()) {
       // Target an implicit subset of columns.
       final SqlNode source = insert.getSource();
       final RelDataType sourceRowType = getNamespace(source).getRowType();
       final RelDataType logicalSourceRowType =
           getLogicalSourceRowType(sourceRowType, insert);
       final RelDataType implicitTargetRowType =
           typeFactory.createStructType(
               targetRowType.getFieldList()
                   .subList(0, logicalSourceRowType.getFieldCount()));
       final SqlValidatorNamespace targetNamespace = getNamespace(insert);
       validateNamespace(targetNamespace, implicitTargetRowType);
       return implicitTargetRowType;
     } else {
       // Either the set of columns are explicitly targeted, or target the full
       // set of columns.
       return targetRowType;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getMatchRecognizeScope ( SqlMatchRecognize node )

inline

Definition at line 1146 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateMatchRecognize().

                                                                           {
     return scopes.get(node);
   }

Here is the caller graph for this function:

SqlValidatorNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace	(	SqlNode	node,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 1158 of file SqlValidatorImpl.java.

                                {
     if (node instanceof SqlIdentifier && scope instanceof DelegatingScope) {
       final SqlIdentifier id = (SqlIdentifier) node;
       final DelegatingScope idScope = (DelegatingScope) ((DelegatingScope) scope).getParent();
       return getNamespace(id, idScope);
     } else if (node instanceof SqlCall) {
       // Handle extended identifiers.
       final SqlCall call = (SqlCall) node;
       switch (call.getOperator().getKind()) {
       case TABLE_REF:
         return getNamespace(call.operand(0), scope);
       case EXTEND:
         final SqlNode operand0 = call.getOperandList().get(0);
         final SqlIdentifier identifier = operand0.getKind() == SqlKind.TABLE_REF
             ? ((SqlCall) operand0).operand(0)
             : (SqlIdentifier) operand0;
         final DelegatingScope idScope = (DelegatingScope) scope;
         return getNamespace(identifier, idScope);
       case AS:
         final SqlNode nested = call.getOperandList().get(0);
         switch (nested.getKind()) {
         case TABLE_REF:
         case EXTEND:
           return getNamespace(nested, scope);
         }
         break;
       }
     }
     return getNamespace(node);
   }

Here is the caller graph for this function:

SqlValidatorNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace	(	SqlIdentifier	id,
		DelegatingScope	scope
	)

inlineprivate

Definition at line 1190 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace().

                                                                                       {
     if (id.isSimple()) {
       final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
       final SqlValidatorScope.ResolvedImpl resolved =
           new SqlValidatorScope.ResolvedImpl();
       scope.resolve(id.names, nameMatcher, false, resolved);
       if (resolved.count() == 1) {
         return resolved.only().namespace;
       }
     }
     return getNamespace(id);
   }

Here is the call graph for this function:

SqlValidatorNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace ( SqlNode node )

inline

Definition at line 1203 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace().

                                                           {
     switch (node.getKind()) {
     case AS:
 
       // AS has a namespace if it has a column list 'AS t (c1, c2, ...)'
       final SqlValidatorNamespace ns = namespaces.get(node);
       if (ns != null) {
         return ns;
       }
       // fall through
     case TABLE_REF:
     case SNAPSHOT:
     case OVER:
     case COLLECTION_TABLE:
     case ORDER_BY:
     case TABLESAMPLE:
       return getNamespace(((SqlCall) node).operand(0));
     default:
       return namespaces.get(node);
     }
   }

Here is the call graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.getNthExpr	(	SqlNode	query,
		int	ordinal,
		int	sourceCount
	)

inlineprivate

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

Definition at line 4723 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkTypeAssignment().

                                                                           {
     if (query instanceof SqlInsert) {
       SqlInsert insert = (SqlInsert) query;
       if (insert.getTargetColumnList() != null) {
         return insert.getTargetColumnList().get(ordinal);
       } else {
         return getNthExpr(
             insert.getSource(),
             ordinal,
             sourceCount);
       }
     } else if (query instanceof SqlUpdate) {
       SqlUpdate update = (SqlUpdate) query;
       if (update.getSourceExpressionList() != null) {
         return update.getSourceExpressionList().get(ordinal);
       } else {
         return getNthExpr(
             update.getSourceSelect(),
             ordinal,
             sourceCount);
       }
     } else if (query instanceof SqlSelect) {
       SqlSelect select = (SqlSelect) query;
       if (select.getSelectList().size() == sourceCount) {
         return select.getSelectList().get(ordinal);
       } else {
         return query; // give up
       }
     } else {
       return query; // give up
     }
   }

Here is the caller graph for this function:

SqlOperatorTable org.apache.calcite.sql.validate.SqlValidatorImpl.getOperatorTable ( )

inline

Definition at line 338 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.opTab.

                                              {
     return opTab;
   }

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getOrderScope ( SqlSelect select )

inline

Definition at line 1142 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.ORDER.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUpInOrderBy(), org.apache.calcite.sql.validate.SqlValidatorImpl.expandOrderExpr(), org.apache.calcite.sql.validate.SqlValidatorImpl.OrderExpressionExpander.OrderExpressionExpander(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderItem(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderList().

                                                            {
     return clauseScopes.get(IdPair.of(select, Clause.ORDER));
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.getOriginal ( SqlNode expr )

inline

Definition at line 5078 of file SqlValidatorImpl.java.

                                            {
     SqlNode original = originalExprs.get(expr);
     if (original == null) {
       original = expr;
     }
     return original;
   }

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getOverScope ( SqlNode node )

inline

Definition at line 1154 of file SqlValidatorImpl.java.

                                                       {
     return scopes.get(node);
   }

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getParameterRowType ( SqlNode sqlQuery )

inline

Definition at line 5597 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType(), and run_benchmark_import.type.

                                                            {
     // NOTE: We assume that bind variables occur in depth-first tree
     // traversal in the same order that they occurred in the SQL text.
     final List<RelDataType> types = new ArrayList<>();
     // NOTE: but parameters on fetch/offset would be counted twice
     // as they are counted in the SqlOrderBy call and the inner SqlSelect call
     final Set<SqlNode> alreadyVisited = new HashSet<>();
     sqlQuery.accept(
         new SqlShuttle() {
 
           @Override public SqlNode visit(SqlDynamicParam param) {
             if (alreadyVisited.add(param)) {
               RelDataType type = getValidatedNodeType(param);
               types.add(type);
             }
             return param;
           }
         });
     return typeFactory.createStructType(
         types,
         new AbstractList<String>() {
           @Override public String get(int index) {
             return "?" + index;
           }
 
           @Override public int size() {
             return types.size();
           }
         });
   }

Here is the call graph for this function:

String org.apache.calcite.sql.validate.SqlValidatorImpl.getParentCursor ( String columnListParamName )

inline

Definition at line 405 of file SqlValidatorImpl.java.

                                                             {
     FunctionParamInfo funcParamInfo = functionCallStack.peek();
     Map<String, String> parentCursorMap =
         funcParamInfo.columnListParamToParentCursorMap;
     return parentCursorMap.get(columnListParamName);
   }

SelectScope org.apache.calcite.sql.validate.SqlValidatorImpl.getRawSelectScope ( SqlSelect select )

inline

Definition at line 1120 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getSelectScope().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar(), org.apache.calcite.sql.validate.SqlValidatorImpl.getAgg(), org.apache.calcite.sql.validate.SqlValidatorImpl.getFieldOrigin(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateModality(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList().

                                                          {
     SqlValidatorScope scope = getSelectScope(select);
     if (scope instanceof AggregatingSelectScope) {
       scope = ((AggregatingSelectScope) scope).getParent();
     }
     return (SelectScope) scope;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getSelectScope ( SqlSelect select )

inline

Definition at line 1116 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.SELECT.

                                                             {
     return clauseScopes.get(IdPair.of(select, Clause.SELECT));
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.getSelfJoinExprForUpdate	(	SqlNode	table,
		String	alias
	)

inlineprotected

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 { UPDATE_SRC_ALIAS}, 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

Definition at line 1595 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), and org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteUpdateToMerge().

                     {
     return null;
   }

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getTableConstructorRowType	(	SqlCall	values,
		SqlValidatorScope	scope
	)

inlinepackage

Returns null if there is no common type. E.g. if the rows have a different number of columns.

Definition at line 1655 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.alias(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveAlias(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), report.rows, and run_benchmark_import.type.

                                {
     final List<SqlNode> rows = values.getOperandList();
     assert rows.size() >= 1;
     final List<RelDataType> rowTypes = new ArrayList<>();
     for (final SqlNode row : rows) {
       assert row.getKind() == SqlKind.ROW;
       SqlCall rowConstructor = (SqlCall) row;
 
       // REVIEW jvs 10-Sept-2003: Once we support single-row queries as
       // rows, need to infer aliases from there.
       final List<String> aliasList = new ArrayList<>();
       final List<RelDataType> typeList = new ArrayList<>();
       for (Ord<SqlNode> column : Ord.zip(rowConstructor.getOperandList())) {
         final String alias = deriveAlias(column.e, column.i);
         aliasList.add(alias);
         final RelDataType type = deriveType(scope, column.e);
         typeList.add(type);
       }
       rowTypes.add(typeFactory.createStructType(typeList, aliasList));
     }
     if (rows.size() == 1) {
       // TODO jvs 10-Oct-2005:  get rid of this workaround once
       // leastRestrictive can handle all cases
       return rowTypes.get(0);
     }
     return typeFactory.leastRestrictive(rowTypes);
   }

Here is the call graph for this function:

TypeCoercion org.apache.calcite.sql.validate.SqlValidatorImpl.getTypeCoercion ( )

inline

Definition at line 3910 of file SqlValidatorImpl.java.

                                         {
     assert config.typeCoercionEnabled();
     return this.typeCoercion;
   }

RelDataTypeFactory org.apache.calcite.sql.validate.SqlValidatorImpl.getTypeFactory ( )

inline

Definition at line 342 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.DeriveTypeVisitor.visit().

                                              {
     return typeFactory;
   }

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getUnknownType ( )

inline

Definition at line 346 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType.

                                       {
     return unknownType;
   }

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType ( SqlNode node )

inline

Definition at line 1685 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeTypeIfKnown(), and run_benchmark_import.type.

                                                         {
     RelDataType type = getValidatedNodeTypeIfKnown(node);
     if (type == null) {
       throw Util.needToImplement(node);
     } else {
       return type;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeTypeIfKnown ( SqlNode node )

inline

Definition at line 1694 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getCatalogReader(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType(), and run_benchmark_import.type.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar(), and org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType().

                                                                {
     final RelDataType type = nodeToTypeMap.get(node);
     if (type != null) {
       return type;
     }
     final SqlValidatorNamespace ns = getNamespace(node);
     if (ns != null) {
       return ns.getType();
     }
     final SqlNode original = originalExprs.get(node);
     if (original != null && original != node) {
       return getValidatedNodeType(original);
     }
     if (node instanceof SqlIdentifier) {
       return getCatalogReader().getNamedType((SqlIdentifier) node);
     }
     return null;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

ValidationErrorFunction org.apache.calcite.sql.validate.SqlValidatorImpl.getValidationErrorFunction ( )

inline

Definition at line 5028 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.validationErrorFunction.

                                                               {
     return validationErrorFunction;
   }

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getWhereScope ( SqlSelect select )

inline

Definition at line 1112 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.Clause.WHERE.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectItem(), org.apache.calcite.sql.validate.SqlValidatorImpl.handleScalarSubQuery(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereClause().

                                                            {
     return clauseScopes.get(IdPair.of(select, Clause.WHERE));
   }

Here is the caller graph for this function:

SqlWindow org.apache.calcite.sql.validate.SqlValidatorImpl.getWindowByName	(	SqlIdentifier	id,
		SqlValidatorScope	scope
	)

inlineprotected

Definition at line 5039 of file SqlValidatorImpl.java.

References setup.name, and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.resolveWindow(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWindow().

                                {
     SqlWindow window = null;
     if (id.isSimple()) {
       final String name = id.getSimple();
       window = scope.lookupWindow(name);
     }
     if (window == null) {
       throw newValidationError(id, RESOURCE.windowNotFound(id.toString()));
     }
     return window;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlWindow org.apache.calcite.sql.validate.SqlValidatorImpl.getWindowInOver ( SqlNode over )

inlineprivate

Definition at line 3565 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp().

                                                   {
     if (over.getKind() == SqlKind.OVER) {
       SqlNode window = ((SqlCall) over).getOperandList().get(1);
       if (window instanceof SqlWindow) {
         return (SqlWindow) window;
       }
       // SqlIdentifier, gets validated elsewhere
       return null;
     }
     return null;
   }

Here is the caller graph for this function:

SqlValidatorScope org.apache.calcite.sql.validate.SqlValidatorImpl.getWithScope ( SqlNode withItem )

inline

Definition at line 3905 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.scopes.

                                                           {
     assert withItem.getKind() == SqlKind.WITH_ITEM;
     return scopes.get(withItem);
   }

void org.apache.calcite.sql.validate.SqlValidatorImpl.handleOffsetFetch	(	SqlNode	offset,
		SqlNode	fetch
	)

inlineprivate

Definition at line 1225 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType(), and org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                                 {
     if (offset instanceof SqlDynamicParam) {
       setValidatedNodeType(offset,
           typeFactory.createSqlType(SqlTypeName.INTEGER));
     }
     if (fetch instanceof SqlDynamicParam) {
       setValidatedNodeType(fetch,
           typeFactory.createSqlType(SqlTypeName.INTEGER));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.handleScalarSubQuery	(	SqlSelect	parentSelect,
		SqlSelect	selectItem,
		List< SqlNode >	expandedSelectItems,
		Set< String >	aliasList,
		List< Map.Entry< String, RelDataType >>	fieldList
	)

inlineprivate

Processes SubQuery found in Select list. Checks that is actually Scalar sub-query 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
fieldList	Built up entries for each select list entry

Definition at line 4270 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.alias(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveAlias(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.getWhereScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType(), and run_benchmark_import.type.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList().

                                                       {
     // A scalar sub-query only has one output column.
     if (1 != selectItem.getSelectList().size()) {
       throw newValidationError(selectItem,
           RESOURCE.onlyScalarSubQueryAllowed());
     }
 
     // No expansion in this routine just append to list.
     expandedSelectItems.add(selectItem);
 
     // Get or generate alias and add to list.
     final String alias =
         deriveAlias(
             selectItem,
             aliasList.size());
     aliasList.add(alias);
 
     final SelectScope scope = (SelectScope) getWhereScope(parentSelect);
     final RelDataType type = deriveType(scope, selectItem);
     setValidatedNodeType(selectItem, type);
 
     // We do not want to pass on the RelRecordType returned
     // by the sub-query.  Just the type of the single expression
     // in the sub-query select list.
     assert type instanceof RelRecordType;
     RelRecordType rec = (RelRecordType) type;
 
     RelDataType nodeType = rec.getFieldList().get(0).getType();
     nodeType = typeFactory.createTypeWithNullability(nodeType, true);
     fieldList.add(Pair.of(alias, nodeType));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

CalciteException org.apache.calcite.sql.validate.SqlValidatorImpl.handleUnresolvedFunction	(	SqlCall	call,
		SqlFunction	unresolvedFunction,
		List< RelDataType >	argTypes,
		List< String >	argNames
	)

inline

Definition at line 1843 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.catalogReader, getMin(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.deriveConstructorType(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateCall().

                              {
     // For builtins, we can give a better error message
     final List<SqlOperator> overloads = new ArrayList<>();
     opTab.lookupOperatorOverloads(unresolvedFunction.getNameAsId(), null,
         SqlSyntax.FUNCTION, overloads, catalogReader.nameMatcher());
     if (overloads.size() == 1) {
       SqlFunction fun = (SqlFunction) overloads.get(0);
       if ((fun.getSqlIdentifier() == null)
           && (fun.getSyntax() != SqlSyntax.FUNCTION_ID)) {
         final int expectedArgCount =
             fun.getOperandCountRange().getMin();
         throw newValidationError(call,
             RESOURCE.invalidArgCount(call.getOperator().getName(),
                 expectedArgCount));
       }
     }
 
     AssignableOperandTypeChecker typeChecking =
         new AssignableOperandTypeChecker(argTypes, argNames);
     String signature =
         typeChecking.getAllowedSignatures(
             unresolvedFunction,
             unresolvedFunction.getName());
     throw newValidationError(call,
         RESOURCE.validatorUnknownFunction(signature));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.hasSortedPrefix	(	SelectScope	scope,
		SqlNodeList	orderList
	)

inlineprivate

Returns whether the prefix is sorted.

Definition at line 3778 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.isSortCompatible().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateModality().

                                                                             {
     return isSortCompatible(scope, orderList.get(0), false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.inferUnknownTypes	(	@Nonnull RelDataType	inferredType,
		@Nonnull SqlValidatorScope	scope,
		@Nonnull SqlNode	node
	)

inlineprotected

Definition at line 1872 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.booleanType, org.apache.calcite.sql.validate.SqlValidatorImpl.config(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType(), run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType.

                              {
     Objects.requireNonNull(inferredType);
     Objects.requireNonNull(scope);
     Objects.requireNonNull(node);
     final SqlValidatorScope newScope = scopes.get(node);
     if (newScope != null) {
       scope = newScope;
     }
     boolean isNullLiteral = SqlUtil.isNullLiteral(node, false);
     if ((node instanceof SqlDynamicParam) || isNullLiteral) {
       if (inferredType.equals(unknownType)) {
         if (isNullLiteral) {
           if (config.typeCoercionEnabled()) {
             // derive type of null literal
             deriveType(scope, node);
             return;
           } else {
             throw newValidationError(node, RESOURCE.nullIllegal());
           }
         } else {
           throw newValidationError(node, RESOURCE.dynamicParamIllegal());
         }
       }
 
       // REVIEW:  should dynamic parameter types always be nullable?
       RelDataType newInferredType =
           typeFactory.createTypeWithNullability(inferredType, true);
       if (SqlTypeUtil.inCharFamily(inferredType)) {
         newInferredType =
             typeFactory.createTypeWithCharsetAndCollation(
                 newInferredType,
                 inferredType.getCharset(),
                 inferredType.getCollation());
       }
       setValidatedNodeType(node, newInferredType);
     } else if (node instanceof SqlNodeList) {
       SqlNodeList nodeList = (SqlNodeList) node;
       if (inferredType.isStruct()) {
         if (inferredType.getFieldCount() != nodeList.size()) {
           // this can happen when we're validating an INSERT
           // where the source and target degrees are different;
           // bust out, and the error will be detected higher up
           return;
         }
       }
       int i = 0;
       for (SqlNode child : nodeList) {
         RelDataType type;
         if (inferredType.isStruct()) {
           type = inferredType.getFieldList().get(i).getType();
           ++i;
         } else {
           type = inferredType;
         }
         inferUnknownTypes(type, scope, child);
       }
     } else if (node instanceof SqlCase) {
       final SqlCase caseCall = (SqlCase) node;
 
       final RelDataType whenType =
           caseCall.getValueOperand() == null ? booleanType : unknownType;
       for (SqlNode sqlNode : caseCall.getWhenOperands().getList()) {
         inferUnknownTypes(whenType, scope, sqlNode);
       }
       RelDataType returnType = deriveType(scope, node);
       for (SqlNode sqlNode : caseCall.getThenOperands().getList()) {
         inferUnknownTypes(returnType, scope, sqlNode);
       }
 
       if (!SqlUtil.isNullLiteral(caseCall.getElseOperand(), false)) {
         inferUnknownTypes(
             returnType,
             scope,
             caseCall.getElseOperand());
       } else {
         setValidatedNodeType(caseCall.getElseOperand(), returnType);
       }
     } else if (node.getKind()  == SqlKind.AS) {
       // For AS operator, only infer the operand not the alias
       inferUnknownTypes(inferredType, scope, ((SqlCall) node).operand(0));
     } else if (node instanceof SqlCall) {
       final SqlCall call = (SqlCall) node;
       final SqlOperandTypeInference operandTypeInference =
           call.getOperator().getOperandTypeInference();
       final SqlCallBinding callBinding = new SqlCallBinding(this, scope, call);
       final List<SqlNode> operands = callBinding.operands();
       final RelDataType[] operandTypes = new RelDataType[operands.size()];
       Arrays.fill(operandTypes, unknownType);
       // TODO:  eventually should assert(operandTypeInference != null)
       // instead; for now just eat it
       if (operandTypeInference != null) {
         operandTypeInference.inferOperandTypes(
             callBinding,
             inferredType,
             operandTypes);
       }
       for (int i = 0; i < operands.size(); ++i) {
         final SqlNode operand = operands.get(i);
         if (operand != null) {
           inferUnknownTypes(operandTypes[i], scope, operand);
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregate ( SqlSelect select )

inline

Definition at line 2894 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getAggregate(), org.apache.calcite.sql.validate.SqlValidatorImpl.isNestedAggregateWindow(), org.apache.calcite.sql.validate.SqlValidatorImpl.isOverAggregateWindow(), and org.apache.calcite.sql.validate.SqlValidatorImpl.overFinder.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.ExtendedExpander.visit().

                                                {
     if (getAggregate(select) != null) {
       return true;
     }
     // Also when nested window aggregates are present
     for (SqlCall call : overFinder.findAll(select.getSelectList())) {
       assert call.getKind() == SqlKind.OVER;
       if (isNestedAggregateWindow(call.operand(0))) {
         return true;
       }
       if (isOverAggregateWindow(call.operand(1))) {
         return true;
       }
     }
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregate ( SqlNode selectNode )

inline

Definition at line 2954 of file SqlValidatorImpl.java.

                                                            {
     return aggFinder.findAgg(selectNode) != null;
   }

static boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregation ( SqlKind kind )

inlinestaticprivate

Definition at line 5643 of file SqlValidatorImpl.java.

References MIN.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), org.apache.calcite.sql.validate.SqlValidatorImpl.isSingleVarRequired(), org.apache.calcite.sql.validate.SqlValidatorImpl.NavigationReplacer.visit(), and org.apache.calcite.sql.validate.SqlValidatorImpl.PatternValidator.visit().

                                                      {
     return kind == SqlKind.SUM || kind == SqlKind.SUM0
         || kind == SqlKind.AVG || kind == SqlKind.COUNT
         || kind == SqlKind.MAX || kind == SqlKind.MIN;
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isLogicalNavigation ( SqlKind kind )

inlinestaticprivate

Definition at line 5639 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isSingleVarRequired(), org.apache.calcite.sql.validate.SqlValidatorImpl.NavigationExpander.visit(), org.apache.calcite.sql.validate.SqlValidatorImpl.NavigationReplacer.visit(), and org.apache.calcite.sql.validate.SqlValidatorImpl.PatternValidator.visit().

                                                            {
     return kind == SqlKind.FIRST || kind == SqlKind.LAST;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isNestedAggregateWindow ( SqlNode node )

inlineprotected

Definition at line 2911 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.aggFinder, org.apache.calcite.sql.validate.SqlValidatorImpl.catalogReader, and org.apache.calcite.sql.validate.SqlValidatorImpl.opTab.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregate().

                                                           {
     AggFinder nestedAggFinder =
         new AggFinder(opTab, false, false, false, aggFinder,
             catalogReader.nameMatcher());
     return nestedAggFinder.findAgg(node) != null;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isOverAggregateWindow ( SqlNode node )

inlineprotected

Definition at line 2918 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregate().

                                                         {
     return aggFinder.findAgg(node) != null;
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isPhysicalNavigation ( SqlKind kind )

inlinestaticprivate

Definition at line 5635 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isSingleVarRequired(), org.apache.calcite.sql.validate.SqlValidatorImpl.NavigationExpander.visit(), and org.apache.calcite.sql.validate.SqlValidatorImpl.PatternValidator.visit().

                                                             {
     return kind == SqlKind.PREV || kind == SqlKind.NEXT;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isRolledUpColumn	(	SqlIdentifier	identifier,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 3625 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.findTableColumnPair().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp(), and org.apache.calcite.sql.validate.SqlValidatorImpl.expandStar().

                                                                                       {
     Pair<String, String> pair = findTableColumnPair(identifier, scope);
 
     if (pair == null) {
       return false;
     }
 
     String columnName = pair.right;
 
     SqlValidatorTable sqlValidatorTable =
         scope.fullyQualify(identifier).namespace.getTable();
     if (sqlValidatorTable != null) {
       Table table = sqlValidatorTable.unwrap(Table.class);
       return table.isRolledUp(columnName);
     }
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isRolledUpColumnAllowedInAgg	(	SqlIdentifier	identifier,
		SqlValidatorScope	scope,
		SqlCall	aggCall,
		SqlNode	parent
	)

inlineprivate

Definition at line 3603 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.findTableColumnPair().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp().

                                                                                 {
     Pair<String, String> pair = findTableColumnPair(identifier, scope);
 
     if (pair == null) {
       return true;
     }
 
     String columnName = pair.right;
 
     SqlValidatorTable sqlValidatorTable =
         scope.fullyQualify(identifier).namespace.getTable();
     if (sqlValidatorTable != null) {
       Table table = sqlValidatorTable.unwrap(Table.class);
       return table.rolledUpColumnValidInsideAgg(columnName, aggCall, parent,
           catalogReader.getConfig());
     }
     return true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isRowWithDefault	(	SqlNode	operand,
		int	column
	)

inlineprivate

Definition at line 4591 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isValuesWithDefault().

                                                                 {
     switch (operand.getKind()) {
     case ROW:
       final SqlCall row = (SqlCall) operand;
       return row.getOperandList().size() >= column
           && row.getOperandList().get(column).getKind() == SqlKind.DEFAULT;
     }
     return false;
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isRunningOrFinal ( SqlKind kind )

inlinestaticprivate

Definition at line 5649 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.navigationInMeasure(), org.apache.calcite.sql.validate.SqlValidatorImpl.NavigationReplacer.visit(), and org.apache.calcite.sql.validate.SqlValidatorImpl.PatternValidator.visit().

                                                         {
     return kind == SqlKind.RUNNING || kind == SqlKind.FINAL;
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isSingleVarRequired ( SqlKind kind )

inlinestaticprivate

Definition at line 5653 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregation(), org.apache.calcite.sql.validate.SqlValidatorImpl.isLogicalNavigation(), and org.apache.calcite.sql.validate.SqlValidatorImpl.isPhysicalNavigation().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.PatternValidator.visit().

                                                            {
     return isPhysicalNavigation(kind)
         || isLogicalNavigation(kind)
         || isAggregation(kind);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isSortCompatible	(	SelectScope	scope,
		SqlNode	node,
		boolean	descending
	)

inlineprivate

Definition at line 3782 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.hasSortedPrefix().

                           {
     switch (node.getKind()) {
     case DESCENDING:
       return isSortCompatible(scope, ((SqlCall) node).getOperandList().get(0),
           true);
     }
     final SqlMonotonicity monotonicity = scope.getMonotonicity(node);
     switch (monotonicity) {
     case INCREASING:
     case STRICTLY_INCREASING:
       return !descending;
     case DECREASING:
     case STRICTLY_DECREASING:
       return descending;
     default:
       return false;
     }
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isSystemField ( RelDataTypeField field )

inline

Definition at line 5544 of file SqlValidatorImpl.java.

                                                        {
     return false;
   }

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.isValuesWithDefault	(	SqlNode	source,
		int	column
	)

inlineprivate

Returns whether a query uses

DEFAULT

to populate a given column.

Definition at line 4578 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.isRowWithDefault().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkFieldCount().

                                                                   {
     switch (source.getKind()) {
     case VALUES:
       for (SqlNode operand : ((SqlCall) source).getOperandList()) {
         if (!isRowWithDefault(operand, column)) {
           return false;
         }
       }
       return true;
     }
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlValidatorNamespace org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFieldNamespace	(	RelDataType	rowType,
		String	name
	)

inlinepackage

Definition at line 5091 of file SqlValidatorImpl.java.

References field(), and setup.name.

                                                                                {
     final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
     final RelDataTypeField field = nameMatcher.field(rowType, name);
     if (field == null) {
       return null;
     }
     return new FieldNamespace(this, field.getType());
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFromHints	(	SqlNode	node,
		SqlValidatorScope	scope,
		SqlParserPos	pos,
		Collection< SqlMoniker >	hintList
	)

inlineprivate

Definition at line 828 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getCatalogReader(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.lookupJoinHints(), and org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupJoinHints(), and org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints().

                                        {
     if (node == null) {
       // This can happen in cases like "select * _suggest_", so from clause is absent
       return;
     }
     final SqlValidatorNamespace ns = getNamespace(node);
     if (ns.isWrapperFor(IdentifierNamespace.class)) {
       IdentifierNamespace idNs = ns.unwrap(IdentifierNamespace.class);
       final SqlIdentifier id = idNs.getId();
       for (int i = 0; i < id.names.size(); i++) {
         if (pos.toString().equals(
             id.getComponent(i).getParserPosition().toString())) {
           final List<SqlMoniker> objNames = new ArrayList<>();
           SqlValidatorUtil.getSchemaObjectMonikers(
               getCatalogReader(),
               id.names.subList(0, i + 1),
               objNames);
           for (SqlMoniker objName : objNames) {
             if (objName.getType() != SqlMonikerType.FUNCTION) {
               hintList.add(objName);
             }
           }
           return;
         }
       }
     }
     switch (node.getKind()) {
     case JOIN:
       lookupJoinHints((SqlJoin) node, scope, pos, hintList);
       break;
     default:
       lookupSelectHints(ns, pos, hintList);
       break;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

List<SqlMoniker> org.apache.calcite.sql.validate.SqlValidatorImpl.lookupHints	(	SqlNode	topNode,
		SqlParserPos	pos
	)

inline

Definition at line 760 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints(), org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

                                                                          {
     SqlValidatorScope scope = new EmptyScope(this);
     SqlNode outermostNode = performUnconditionalRewrites(topNode, false);
     cursorSet.add(outermostNode);
     if (outermostNode.isA(SqlKind.TOP_LEVEL)) {
       registerQuery(
           scope,
           null,
           outermostNode,
           outermostNode,
           null,
           false);
     }
     final SqlValidatorNamespace ns = getNamespace(outermostNode);
     if (ns == null) {
       throw new AssertionError("Not a query: " + outermostNode);
     }
     Collection<SqlMoniker> hintList = Sets.newTreeSet(SqlMoniker.COMPARATOR);
     lookupSelectHints(ns, pos, hintList);
     return ImmutableList.copyOf(hintList);
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.lookupJoinHints	(	SqlJoin	join,
		SqlValidatorScope	scope,
		SqlParserPos	pos,
		Collection< SqlMoniker >	hintList
	)

inlineprivate

Definition at line 868 of file SqlValidatorImpl.java.

References join(), and org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFromHints().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFromHints().

                                        {
     SqlNode left = join.getLeft();
     SqlNode right = join.getRight();
     SqlNode condition = join.getCondition();
     lookupFromHints(left, scope, pos, hintList);
     if (hintList.size() > 0) {
       return;
     }
     lookupFromHints(right, scope, pos, hintList);
     if (hintList.size() > 0) {
       return;
     }
     final JoinConditionType conditionType = join.getConditionType();
     final SqlValidatorScope joinScope = scopes.get(join);
     switch (conditionType) {
     case ON:
       condition.findValidOptions(this, joinScope, pos, hintList);
       return;
     default:
 
       // No suggestions.
       // Not supporting hints for other types such as 'Using' yet.
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

final void org.apache.calcite.sql.validate.SqlValidatorImpl.lookupNameCompletionHints	(	SqlValidatorScope	scope,
		List< String >	names,
		SqlParserPos	pos,
		Collection< SqlMoniker >	hintList
	)

inline

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

Definition at line 905 of file SqlValidatorImpl.java.

References field(), org.apache.calcite.sql.validate.SqlValidatorImpl.findAllValidFunctionNames(), org.apache.calcite.sql.validate.SqlValidatorImpl.findAllValidUdfNames(), and setup.name.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints().

                                        {
     // Remove the last part of name - it is a dummy
     List<String> subNames = Util.skipLast(names);
 
     if (subNames.size() > 0) {
       // If there's a prefix, resolve it to a namespace.
       SqlValidatorNamespace ns = null;
       for (String name : subNames) {
         if (ns == null) {
           final SqlValidatorScope.ResolvedImpl resolved =
               new SqlValidatorScope.ResolvedImpl();
           final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
           scope.resolve(ImmutableList.of(name), nameMatcher, false, resolved);
           if (resolved.count() == 1) {
             ns = resolved.only().namespace;
           }
         } else {
           ns = ns.lookupChild(name);
         }
         if (ns == null) {
           break;
         }
       }
       if (ns != null) {
         RelDataType rowType = ns.getRowType();
         if (rowType.isStruct()) {
           for (RelDataTypeField field : rowType.getFieldList()) {
             hintList.add(
                 new SqlMonikerImpl(
                     field.getName(),
                     SqlMonikerType.COLUMN));
           }
         }
       }
 
       // builtin function names are valid completion hints when the
       // identifier has only 1 name part
       findAllValidFunctionNames(names, this, hintList, pos);
     } else {
       // No prefix; use the children of the current scope (that is,
       // the aliases in the FROM clause)
       scope.findAliases(hintList);
 
       // If there's only one alias, add all child columns
       SelectScope selectScope =
           SqlValidatorUtil.getEnclosingSelectScope(scope);
       if ((selectScope != null)
           && (selectScope.getChildren().size() == 1)) {
         RelDataType rowType =
             selectScope.getChildren().get(0).getRowType();
         for (RelDataTypeField field : rowType.getFieldList()) {
           hintList.add(
               new SqlMonikerImpl(
                   field.getName(),
                   SqlMonikerType.COLUMN));
         }
       }
     }
 
     findAllValidUdfNames(names, this, hintList);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlMoniker org.apache.calcite.sql.validate.SqlValidatorImpl.lookupQualifiedName	(	SqlNode	topNode,
		SqlParserPos	pos
	)

inline

Definition at line 782 of file SqlValidatorImpl.java.

                                                                            {
     final String posString = pos.toString();
     IdInfo info = idPositions.get(posString);
     if (info != null) {
       final SqlQualified qualified = info.scope.fullyQualify(info.id);
       return new SqlIdentifierMoniker(qualified.identifier);
     } else {
       return null;
     }
   }

void org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints	(	SqlSelect	select,
		SqlParserPos	pos,
		Collection< SqlMoniker >	hintList
	)

inlinepackage

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

Definition at line 803 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getFromScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.IdInfo.id, org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFromHints(), org.apache.calcite.sql.validate.SqlValidatorImpl.lookupNameCompletionHints(), and org.apache.calcite.sql.validate.SqlValidatorImpl.IdInfo.scope.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupFromHints(), org.apache.calcite.sql.validate.SqlValidatorImpl.lookupHints(), and org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints().

                                        {
     IdInfo info = idPositions.get(pos.toString());
     if ((info == null) || (info.scope == null)) {
       SqlNode fromNode = select.getFrom();
       final SqlValidatorScope fromScope = getFromScope(select);
       lookupFromHints(fromNode, fromScope, pos, hintList);
     } else {
       lookupNameCompletionHints(info.scope, info.id.names,
           info.id.getParserPosition(), hintList);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints	(	SqlValidatorNamespace	ns,
		SqlParserPos	pos,
		Collection< SqlMoniker >	hintList
	)

inlineprivate

Definition at line 818 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.lookupSelectHints().

                                        {
     final SqlNode node = ns.getNode();
     if (node instanceof SqlSelect) {
       lookupSelectHints((SqlSelect) node, pos, hintList);
     }
   }

Here is the call graph for this function:

SqlCall org.apache.calcite.sql.validate.SqlValidatorImpl.makeNullaryCall ( SqlIdentifier id )

inline

Definition at line 1737 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.findTableColumnPair(), and org.apache.calcite.sql.validate.SqlValidatorImpl.DeriveTypeVisitor.visit().

                                                              {
     if (id.names.size() == 1 && !id.isComponentQuoted(0)) {
       final List<SqlOperator> list = new ArrayList<>();
       opTab.lookupOperatorOverloads(id, null, SqlSyntax.FUNCTION, list,
           catalogReader.nameMatcher());
       for (SqlOperator operator : list) {
         if (operator.getSyntax() == SqlSyntax.FUNCTION_ID) {
           // Even though this looks like an identifier, it is a
           // actually a call to a function. Construct a fake
           // call to this function, so we can use the regular
           // operator validation.
           return new SqlBasicCall(operator, SqlNode.EMPTY_ARRAY,
               id.getParserPosition(), true, null);
         }
       }
     }
     return null;
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.maybeCast	(	SqlNode	node,
		RelDataType	currentType,
		RelDataType	desiredType
	)

inlineprivate

Definition at line 714 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.Permute.permute().

                                {
     return SqlTypeUtil.equalSansNullability(typeFactory, currentType, desiredType)
         ? node
         : SqlStdOperatorTable.CAST.createCall(SqlParserPos.ZERO,
             node, SqlTypeUtil.convertTypeToSpec(desiredType));
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.navigationInDefine	(	SqlNode	node,
		String	alpha
	)

inlineprivate

Checks that all pattern variables within a function are the same, and canonizes expressions such as

PREV(B.price)

to

LAST(B.price, 0)

.

Definition at line 5391 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateDefinitions().

                                                                  {
     Set<String> prefix = node.accept(new PatternValidator(false));
     Util.discard(prefix);
     node = new NavigationExpander().go(node);
     node = new NavigationReplacer(alpha).go(node);
     return node;
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.navigationInMeasure	(	SqlNode	node,
		boolean	allRows
	)

inlineprivate

Definition at line 5318 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.isRunningOrFinal().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateMeasure().

                                                                      {
     final Set<String> prefix = node.accept(new PatternValidator(true));
     Util.discard(prefix);
     final List<SqlNode> ops = ((SqlCall) node).getOperandList();
 
     final SqlOperator defaultOp =
         allRows ? SqlStdOperatorTable.RUNNING : SqlStdOperatorTable.FINAL;
     final SqlNode op0 = ops.get(0);
     if (!isRunningOrFinal(op0.getKind())
         || !allRows && op0.getKind() == SqlKind.RUNNING) {
       SqlNode newNode = defaultOp.createCall(SqlParserPos.ZERO, op0);
       node = SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO, newNode, ops.get(1));
     }
 
     node = new NavigationExpander().go(node);
     return node;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

CalciteContextException org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError	(	SqlNode	node,
		Resources.ExInst< SqlValidatorException >	e
	)

inline

Definition at line 5032 of file SqlValidatorImpl.java.

                                                  {
     assert node != null;
     final SqlParserPos pos = node.getParserPosition();
     return SqlUtil.newContextException(pos, e);
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites	(	SqlNode	node,
		boolean	underFrom
	)

inlineprotected

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

Definition at line 1245 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupHints(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateScopedExpression().

                          {
     if (node == null) {
       return null;
     }
 
     SqlNode newOperand;
 
     // first transform operands and invoke generic call rewrite
     if (node instanceof SqlCall) {
       if (node instanceof SqlMerge) {
         validatingSqlMerge = true;
       }
       SqlCall call = (SqlCall) node;
       final SqlKind kind = call.getKind();
       final List<SqlNode> operands = call.getOperandList();
       for (int i = 0; i < operands.size(); i++) {
         SqlNode operand = operands.get(i);
         boolean childUnderFrom;
         if (kind == SqlKind.SELECT) {
           childUnderFrom = i == SqlSelect.FROM_OPERAND;
         } else if (kind == SqlKind.AS && (i == 0)) {
           // for an aliased expression, it is under FROM if
           // the AS expression is under FROM
           childUnderFrom = underFrom;
         } else {
           childUnderFrom = false;
         }
         newOperand =
             performUnconditionalRewrites(operand, childUnderFrom);
         if (newOperand != null && newOperand != operand) {
           call.setOperand(i, newOperand);
         }
       }
 
       if (call.getOperator() instanceof SqlUnresolvedFunction) {
         assert call instanceof SqlBasicCall;
         final SqlUnresolvedFunction function =
             (SqlUnresolvedFunction) call.getOperator();
         // This function hasn't been resolved yet.  Perform
         // a half-hearted resolution now in case it's a
         // builtin function requiring special casing.  If it's
         // not, we'll handle it later during overload resolution.
         final List<SqlOperator> overloads = new ArrayList<>();
         opTab.lookupOperatorOverloads(function.getNameAsId(),
             function.getFunctionType(), SqlSyntax.FUNCTION, overloads,
             catalogReader.nameMatcher());
         if (overloads.size() == 1) {
           ((SqlBasicCall) call).setOperator(overloads.get(0));
         }
       }
       if (config.callRewrite()) {
         node = call.getOperator().rewriteCall(this, call);
       }
     } else if (node instanceof SqlNodeList) {
       SqlNodeList list = (SqlNodeList) node;
       for (int i = 0, count = list.size(); i < count; i++) {
         SqlNode operand = list.get(i);
         newOperand =
             performUnconditionalRewrites(
                 operand,
                 false);
         if (newOperand != null) {
           list.getList().set(i, newOperand);
         }
       }
     }
 
     // now transform node itself
     final SqlKind kind = node.getKind();
     switch (kind) {
     case VALUES:
       // CHECKSTYLE: IGNORE 1
       if (underFrom || true) {
         // leave FROM (VALUES(...)) [ AS alias ] clauses alone,
         // otherwise they grow cancerously if this rewrite is invoked
         // over and over
         return node;
       } else {
         final SqlNodeList selectList =
             new SqlNodeList(SqlParserPos.ZERO);
         selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
         return new SqlSelect(node.getParserPosition(), null, selectList, node,
             null, null, null, null, null, null, null, null);
       }
 
     case ORDER_BY: {
       SqlOrderBy orderBy = (SqlOrderBy) node;
       handleOffsetFetch(orderBy.offset, orderBy.fetch);
       if (orderBy.query instanceof SqlSelect) {
         SqlSelect select = (SqlSelect) orderBy.query;
 
         // Don't clobber existing ORDER BY.  It may be needed for
         // an order-sensitive function like RANK.
         if (select.getOrderList() == null) {
           // push ORDER BY into existing select
           select.setOrderBy(orderBy.orderList);
           select.setOffset(orderBy.offset);
           select.setFetch(orderBy.fetch);
           return select;
         }
       }
       if (orderBy.query instanceof SqlWith
           && ((SqlWith) orderBy.query).body instanceof SqlSelect) {
         SqlWith with = (SqlWith) orderBy.query;
         SqlSelect select = (SqlSelect) with.body;
 
         // Don't clobber existing ORDER BY.  It may be needed for
         // an order-sensitive function like RANK.
         if (select.getOrderList() == null) {
           // push ORDER BY into existing select
           select.setOrderBy(orderBy.orderList);
           select.setOffset(orderBy.offset);
           select.setFetch(orderBy.fetch);
           return with;
         }
       }
       final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
       selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
       final SqlNodeList orderList;
       if (getInnerSelect(node) != null && isAggregate(getInnerSelect(node))) {
         orderList = SqlNode.clone(orderBy.orderList);
         // We assume that ORDER BY item does not have ASC etc.
         // We assume that ORDER BY item is present in SELECT list.
         for (int i = 0; i < orderList.size(); i++) {
           SqlNode sqlNode = orderList.get(i);
           SqlNodeList selectList2 = getInnerSelect(node).getSelectList();
           for (Ord<SqlNode> sel : Ord.zip(selectList2)) {
             if (stripAs(sel.e).equalsDeep(sqlNode, Litmus.IGNORE)) {
               orderList.set(i,
                   SqlLiteral.createExactNumeric(Integer.toString(sel.i + 1),
                       SqlParserPos.ZERO));
             }
           }
         }
       } else {
         orderList = orderBy.orderList;
       }
       return new SqlSelect(SqlParserPos.ZERO, null, selectList, orderBy.query,
           null, null, null, null, orderList, orderBy.offset,
           orderBy.fetch, null);
     }
 
     case EXPLICIT_TABLE: {
       // (TABLE t) is equivalent to (SELECT * FROM t)
       SqlCall call = (SqlCall) node;
       final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
       selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
       return new SqlSelect(SqlParserPos.ZERO, null, selectList, call.operand(0),
           null, null, null, null, null, null, null, null);
     }
 
     case DELETE: {
       SqlDelete call = (SqlDelete) node;
       SqlSelect select = createSourceSelectForDelete(call);
       call.setSourceSelect(select);
       break;
     }
 
     case UPDATE: {
       SqlUpdate call = (SqlUpdate) node;
       SqlSelect select = createSourceSelectForUpdate(call);
       call.setSourceSelect(select);
 
       // See if we're supposed to rewrite UPDATE to MERGE
       // (unless this is the UPDATE clause of a MERGE,
       // in which case leave it alone).
       if (!validatingSqlMerge) {
         SqlNode selfJoinSrcExpr =
             getSelfJoinExprForUpdate(
                 call.getTargetTable(),
                 UPDATE_SRC_ALIAS);
         if (selfJoinSrcExpr != null) {
           node = rewriteUpdateToMerge(call, selfJoinSrcExpr);
         }
       }
       break;
     }
 
     case MERGE: {
       SqlMerge call = (SqlMerge) node;
       rewriteMerge(call);
       break;
     }
     }
     return node;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.popFunctionCall ( )

inline

Definition at line 400 of file SqlValidatorImpl.java.

                                 {
     functionCallStack.pop();
   }

void org.apache.calcite.sql.validate.SqlValidatorImpl.pushFunctionCall ( )

inline

Definition at line 394 of file SqlValidatorImpl.java.

                                  {
     FunctionParamInfo funcInfo = new FunctionParamInfo();
     functionCallStack.push(funcInfo);
   }

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom	(	SqlValidatorScope	parentScope,
		SqlValidatorScope	usingScope,
		boolean	register,
		final SqlNode	node,
		SqlNode	enclosingNode,
		String	alias,
		SqlNodeList	extendList,
		boolean	forceNullable,
		final boolean	lateral
	)

inlineprivate

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
register	Whether to register this scope as a child of usingScope
node	Node which namespace is based on
enclosingNode	Outermost node for namespace, including decorations such as alias and sample clause
alias	Alias
extendList	Definitions of extended columns
forceNullable	Whether to force the type of namespace to be nullable because it is in an outer join
lateral	Whether LATERAL is specified, so that items to the left of this in the JOIN tree are visible in the scope

Returns: registered node, usually the same as
node

Definition at line 2096 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerMatchRecognize(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

                              {
     final SqlKind kind = node.getKind();
 
     SqlNode expr;
     SqlNode newExpr;
 
     // Add an alias if necessary.
     SqlNode newNode = node;
     if (alias == null) {
       switch (kind) {
       case IDENTIFIER:
       case OVER:
         alias = deriveAlias(node, -1);
         if (alias == null) {
           alias = deriveAlias(node, nextGeneratedId++);
         }
         if (config.identifierExpansion()) {
           newNode = SqlValidatorUtil.addAlias(node, alias);
         }
         break;
 
       case SELECT:
       case UNION:
       case INTERSECT:
       case EXCEPT:
       case VALUES:
       case UNNEST:
       case OTHER_FUNCTION:
       case COLLECTION_TABLE:
       case MATCH_RECOGNIZE:
 
         // give this anonymous construct a name since later
         // query processing stages rely on it
         alias = deriveAlias(node, nextGeneratedId++);
         if (config.identifierExpansion()) {
           // Since we're expanding identifiers, we should make the
           // aliases explicit too, otherwise the expanded query
           // will not be consistent if we convert back to SQL, e.g.
           // "select EXPR$1.EXPR$2 from values (1)".
           newNode = SqlValidatorUtil.addAlias(node, alias);
         }
         break;
       }
     }
 
     if (lateral) {
       SqlValidatorScope s = usingScope;
       while (s instanceof JoinScope) {
         s = ((JoinScope) s).getUsingScope();
       }
       final SqlNode node2 = s != null ? s.getNode() : node;
       final TableScope tableScope = new TableScope(parentScope, node2);
       if (usingScope instanceof ListScope) {
         for (ScopeChild child : ((ListScope) usingScope).children) {
           tableScope.addChild(child.namespace, child.name, child.nullable);
         }
       }
       parentScope = tableScope;
     }
 
     SqlCall call;
     SqlNode operand;
     SqlNode newOperand;
 
     switch (kind) {
     case AS:
       call = (SqlCall) node;
       if (alias == null) {
         alias = call.operand(1).toString();
       }
       final boolean needAlias = call.operandCount() > 2;
       expr = call.operand(0);
       newExpr =
           registerFrom(
               parentScope,
               usingScope,
               !needAlias,
               expr,
               enclosingNode,
               alias,
               extendList,
               forceNullable,
               lateral);
       if (newExpr != expr) {
         call.setOperand(0, newExpr);
       }
 
       // If alias has a column list, introduce a namespace to translate
       // column names. We skipped registering it just now.
       if (needAlias) {
         registerNamespace(
             usingScope,
             alias,
             new AliasNamespace(this, call, enclosingNode),
             forceNullable);
       }
       return node;
     case MATCH_RECOGNIZE:
       registerMatchRecognize(parentScope, usingScope,
           (SqlMatchRecognize) node, enclosingNode, alias, forceNullable);
       return node;
     case TABLESAMPLE:
       call = (SqlCall) node;
       expr = call.operand(0);
       newExpr =
           registerFrom(
               parentScope,
               usingScope,
               true,
               expr,
               enclosingNode,
               alias,
               extendList,
               forceNullable,
               lateral);
       if (newExpr != expr) {
         call.setOperand(0, newExpr);
       }
       return node;
 
     case JOIN:
       final SqlJoin join = (SqlJoin) node;
       final JoinScope joinScope =
           new JoinScope(parentScope, usingScope, join);
       scopes.put(join, joinScope);
       final SqlNode left = join.getLeft();
       final SqlNode right = join.getRight();
       boolean forceLeftNullable = forceNullable;
       boolean forceRightNullable = forceNullable;
       switch (join.getJoinType()) {
       case LEFT:
         forceRightNullable = true;
         break;
       case RIGHT:
         forceLeftNullable = true;
         break;
       case FULL:
         forceLeftNullable = true;
         forceRightNullable = true;
         break;
       }
       final SqlNode newLeft =
           registerFrom(
               parentScope,
               joinScope,
               true,
               left,
               left,
               null,
               null,
               forceLeftNullable,
               lateral);
       if (newLeft != left) {
         join.setLeft(newLeft);
       }
       final SqlNode newRight =
           registerFrom(
               parentScope,
               joinScope,
               true,
               right,
               right,
               null,
               null,
               forceRightNullable,
               lateral);
       if (newRight != right) {
         join.setRight(newRight);
       }
       registerSubQueries(joinScope, join.getCondition());
       final JoinNamespace joinNamespace = new JoinNamespace(this, join);
       registerNamespace(null, null, joinNamespace, forceNullable);
       return join;
 
     case IDENTIFIER:
       final SqlIdentifier id = (SqlIdentifier) node;
       final IdentifierNamespace newNs =
           new IdentifierNamespace(
               this, id, extendList, enclosingNode,
               parentScope);
       registerNamespace(register ? usingScope : null, alias, newNs,
           forceNullable);
       if (tableScope == null) {
         tableScope = new TableScope(parentScope, node);
       }
       tableScope.addChild(newNs, alias, forceNullable);
       if (extendList != null && extendList.size() != 0) {
         return enclosingNode;
       }
       return newNode;
 
     case LATERAL:
       return registerFrom(
           parentScope,
           usingScope,
           register,
           ((SqlCall) node).operand(0),
           enclosingNode,
           alias,
           extendList,
           forceNullable,
           true);
 
     case COLLECTION_TABLE:
       call = (SqlCall) node;
       operand = call.operand(0);
       newOperand =
           registerFrom(
               parentScope,
               usingScope,
               register,
               operand,
               enclosingNode,
               alias,
               extendList,
               forceNullable, lateral);
       if (newOperand != operand) {
         call.setOperand(0, newOperand);
       }
       // If the operator is SqlWindowTableFunction, restricts the scope as
       // its first operand's (the table) scope.
       if (operand instanceof SqlBasicCall) {
         final SqlBasicCall call1 = (SqlBasicCall) operand;
         final SqlOperator op = call1.getOperator();
         if (op instanceof SqlWindowTableFunction
             && call1.operand(0).getKind() == SqlKind.SELECT) {
           scopes.put(node, getSelectScope(call1.operand(0)));
           return newNode;
         }
       }
       // Put the usingScope which can be a JoinScope
       // or a SelectScope, in order to see the left items
       // of the JOIN tree.
       scopes.put(node, usingScope);
       return newNode;
 
     case UNNEST:
       if (!lateral) {
         return registerFrom(parentScope, usingScope, register, node,
             enclosingNode, alias, extendList, forceNullable, true);
       }
     // fall through
     case SELECT:
     case UNION:
     case INTERSECT:
     case EXCEPT:
     case VALUES:
     case WITH:
     case OTHER_FUNCTION:
       if (alias == null) {
         alias = deriveAlias(node, nextGeneratedId++);
       }
       registerQuery(
           parentScope,
           register ? usingScope : null,
           node,
           enclosingNode,
           alias,
           forceNullable);
       return newNode;
 
     case OVER:
       if (!shouldAllowOverRelation()) {
         throw Util.unexpected(kind);
       }
       call = (SqlCall) node;
       final OverScope overScope = new OverScope(usingScope, call);
       scopes.put(call, overScope);
       operand = call.operand(0);
       newOperand =
           registerFrom(
               parentScope,
               overScope,
               true,
               operand,
               enclosingNode,
               alias,
               extendList,
               forceNullable,
               lateral);
       if (newOperand != operand) {
         call.setOperand(0, newOperand);
       }
 
       for (ScopeChild child : overScope.children) {
         registerNamespace(register ? usingScope : null, child.name,
             child.namespace, forceNullable);
       }
 
       return newNode;
 
     case TABLE_REF:
       call = (SqlCall) node;
       registerFrom(parentScope,
           usingScope,
           register,
           call.operand(0),
           enclosingNode,
           alias,
           extendList,
           forceNullable,
           lateral);
       if (extendList != null && extendList.size() != 0) {
         return enclosingNode;
       }
       return newNode;
 
     case EXTEND:
       final SqlCall extend = (SqlCall) node;
       return registerFrom(parentScope,
           usingScope,
           true,
           extend.getOperandList().get(0),
           extend,
           alias,
           (SqlNodeList) extend.getOperandList().get(1),
           forceNullable,
           lateral);
 
     case SNAPSHOT:
       call = (SqlCall) node;
       operand = call.operand(0);
       newOperand = registerFrom(
           parentScope,
           usingScope,
           register,
           operand,
           enclosingNode,
           alias,
           extendList,
           forceNullable,
           lateral);
       if (newOperand != operand) {
         call.setOperand(0, newOperand);
       }
       // Put the usingScope which can be a JoinScope
       // or a SelectScope, in order to see the left items
       // of the JOIN tree.
       scopes.put(node, usingScope);
       return newNode;
 
     default:
       throw Util.unexpected(kind);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerMatchRecognize	(	SqlValidatorScope	parentScope,
		SqlValidatorScope	usingScope,
		SqlMatchRecognize	call,
		SqlNode	enclosingNode,
		String	alias,
		boolean	forceNullable
	)

inlineprivate

Definition at line 2012 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.createMatchRecognizeNameSpace(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerNamespace().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom().

                              {
 
     final MatchRecognizeNamespace matchRecognizeNamespace =
         createMatchRecognizeNameSpace(call, enclosingNode);
     registerNamespace(usingScope, alias, matchRecognizeNamespace, forceNullable);
 
     final MatchRecognizeScope matchRecognizeScope =
         new MatchRecognizeScope(parentScope, call);
     scopes.put(call, matchRecognizeScope);
 
     // parse input query
     SqlNode expr = call.getTableRef();
     SqlNode newExpr = registerFrom(usingScope, matchRecognizeScope, true, expr,
         expr, null, null, forceNullable, false);
     if (expr != newExpr) {
       call.setOperand(0, newExpr);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerNamespace	(	SqlValidatorScope	usingScope,
		String	alias,
		SqlValidatorNamespace	ns,
		boolean	forceNullable
	)

inlineprotected

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 nullable

Definition at line 2054 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.alias().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.declareCursor(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerMatchRecognize(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerSetop(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerWith().

                              {
     namespaces.put(ns.getNode(), ns);
     if (usingScope != null) {
       usingScope.addChild(ns, alias, forceNullable);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerOperandSubQueries	(	SqlValidatorScope	parentScope,
		SqlCall	call,
		int	operandOrdinal
	)

inlineprivate

Registers any sub-queries inside a given call operand, and converts the operand to a scalar sub-query if the operator requires it.

Parameters

parentScope	Parent scope
call	Call
operandOrdinal	Ordinal of operand within call

See Also: SqlOperator::argumentMustBeScalar(int)

Definition at line 3009 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.registerSubQueries().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerSubQueries().

                           {
     SqlNode operand = call.operand(operandOrdinal);
     if (operand == null) {
       return;
     }
     if (operand.getKind().belongsTo(SqlKind.QUERY)
         && call.getOperator().argumentMustBeScalar(operandOrdinal)) {
       operand =
           SqlStdOperatorTable.SCALAR_QUERY.createCall(
               operand.getParserPosition(),
               operand);
       call.setOperand(operandOrdinal, operand);
     }
     registerSubQueries(parentScope, operand);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery	(	SqlValidatorScope	parentScope,
		SqlValidatorScope	usingScope,
		SqlNode	node,
		SqlNode	enclosingNode,
		String	alias,
		boolean	forceNullable
	)

inlineprivate

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

Definition at line 2494 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.lookupHints(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerSetop(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerSubQueries(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerWith(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateScopedExpression().

                              {
     Preconditions.checkArgument(usingScope == null || alias != null);
     registerQuery(
         parentScope,
         usingScope,
         node,
         enclosingNode,
         alias,
         forceNullable,
         true);
   }

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery	(	SqlValidatorScope	parentScope,
		SqlValidatorScope	usingScope,
		SqlNode	node,
		SqlNode	enclosingNode,
		String	alias,
		boolean	forceNullable,
		boolean	checkUpdate
	)

inlineprivate

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

Definition at line 2524 of file SqlValidatorImpl.java.

                            {
     Objects.requireNonNull(node);
     Objects.requireNonNull(enclosingNode);
     Preconditions.checkArgument(usingScope == null || alias != null);
 
     SqlCall call;
     List<SqlNode> operands;
     switch (node.getKind()) {
     case SELECT:
       final SqlSelect select = (SqlSelect) node;
       final SelectNamespace selectNs =
           createSelectNamespace(select, enclosingNode);
       registerNamespace(usingScope, alias, selectNs, forceNullable);
       final SqlValidatorScope windowParentScope =
           (usingScope != null) ? usingScope : parentScope;
       SelectScope selectScope =
           new SelectScope(parentScope, windowParentScope, select);
       scopes.put(select, selectScope);
 
       // Start by registering the WHERE clause
       clauseScopes.put(IdPair.of(select, Clause.WHERE), selectScope);
       registerOperandSubQueries(
           selectScope,
           select,
           SqlSelect.WHERE_OPERAND);
 
       // Register FROM with the inherited scope 'parentScope', not
       // 'selectScope', otherwise tables in the FROM clause would be
       // able to see each other.
       final SqlNode from = select.getFrom();
       if (from != null) {
         final SqlNode newFrom =
             registerFrom(
                 parentScope,
                 selectScope,
                 true,
                 from,
                 from,
                 null,
                 null,
                 false,
                 false);
         if (newFrom != from) {
           select.setFrom(newFrom);
         }
       }
 
       // If this is an aggregating query, the SELECT list and HAVING
       // clause use a different scope, where you can only reference
       // columns which are in the GROUP BY clause.
       SqlValidatorScope aggScope = selectScope;
       if (isAggregate(select)) {
         aggScope =
             new AggregatingSelectScope(selectScope, select, false);
         clauseScopes.put(IdPair.of(select, Clause.SELECT), aggScope);
       } else {
         clauseScopes.put(IdPair.of(select, Clause.SELECT), selectScope);
       }
       if (select.getGroup() != null) {
         GroupByScope groupByScope =
             new GroupByScope(selectScope, select.getGroup(), select);
         clauseScopes.put(IdPair.of(select, Clause.GROUP_BY), groupByScope);
         registerSubQueries(groupByScope, select.getGroup());
       }
       registerOperandSubQueries(
           aggScope,
           select,
           SqlSelect.HAVING_OPERAND);
       registerSubQueries(aggScope, select.getSelectList());
       final SqlNodeList orderList = select.getOrderList();
       if (orderList != null) {
         // If the query is 'SELECT DISTINCT', restrict the columns
         // available to the ORDER BY clause.
         if (select.isDistinct()) {
           aggScope =
               new AggregatingSelectScope(selectScope, select, true);
         }
         OrderByScope orderScope =
             new OrderByScope(aggScope, orderList, select);
         clauseScopes.put(IdPair.of(select, Clause.ORDER), orderScope);
         registerSubQueries(orderScope, orderList);
 
         if (!isAggregate(select)) {
           // Since this is not an aggregating query,
           // there cannot be any aggregates in the ORDER BY clause.
           SqlNode agg = aggFinder.findAgg(orderList);
           if (agg != null) {
             throw newValidationError(agg, RESOURCE.aggregateIllegalInOrderBy());
           }
         }
       }
       break;
 
     case INTERSECT:
       validateFeature(RESOURCE.sQLFeature_F302(), node.getParserPosition());
       registerSetop(
           parentScope,
           usingScope,
           node,
           node,
           alias,
           forceNullable);
       break;
 
     case EXCEPT:
       validateFeature(RESOURCE.sQLFeature_E071_03(), node.getParserPosition());
       registerSetop(
           parentScope,
           usingScope,
           node,
           node,
           alias,
           forceNullable);
       break;
 
     case UNION:
       registerSetop(
           parentScope,
           usingScope,
           node,
           node,
           alias,
           forceNullable);
       break;
 
     case WITH:
       registerWith(parentScope, usingScope, (SqlWith) node, enclosingNode,
           alias, forceNullable, checkUpdate);
       break;
 
     case VALUES:
       call = (SqlCall) node;
       scopes.put(call, parentScope);
       final TableConstructorNamespace tableConstructorNamespace =
           new TableConstructorNamespace(
               this,
               call,
               parentScope,
               enclosingNode);
       registerNamespace(
           usingScope,
           alias,
           tableConstructorNamespace,
           forceNullable);
       operands = call.getOperandList();
       for (int i = 0; i < operands.size(); ++i) {
         assert operands.get(i).getKind() == SqlKind.ROW;
 
         // FIXME jvs 9-Feb-2005:  Correlation should
         // be illegal in these sub-queries.  Same goes for
         // any non-lateral SELECT in the FROM list.
         registerOperandSubQueries(parentScope, call, i);
       }
       break;
 
     case INSERT:
       SqlInsert insertCall = (SqlInsert) node;
       InsertNamespace insertNs =
           new InsertNamespace(
               this,
               insertCall,
               enclosingNode,
               parentScope);
       registerNamespace(usingScope, null, insertNs, forceNullable);
       registerQuery(
           parentScope,
           usingScope,
           insertCall.getSource(),
           enclosingNode,
           null,
           false);
       break;
 
     case DELETE:
       SqlDelete deleteCall = (SqlDelete) node;
       DeleteNamespace deleteNs =
           new DeleteNamespace(
               this,
               deleteCall,
               enclosingNode,
               parentScope);
       registerNamespace(usingScope, null, deleteNs, forceNullable);
       registerQuery(
           parentScope,
           usingScope,
           deleteCall.getSourceSelect(),
           enclosingNode,
           null,
           false);
       break;
 
     case UPDATE:
       if (checkUpdate) {
         validateFeature(RESOURCE.sQLFeature_E101_03(),
             node.getParserPosition());
       }
       SqlUpdate updateCall = (SqlUpdate) node;
       UpdateNamespace updateNs =
           new UpdateNamespace(
               this,
               updateCall,
               enclosingNode,
               parentScope);
       registerNamespace(usingScope, null, updateNs, forceNullable);
       registerQuery(
           parentScope,
           usingScope,
           updateCall.getSourceSelect(),
           enclosingNode,
           null,
           false);
       break;
 
     case MERGE:
       validateFeature(RESOURCE.sQLFeature_F312(), node.getParserPosition());
       SqlMerge mergeCall = (SqlMerge) node;
       MergeNamespace mergeNs =
           new MergeNamespace(
               this,
               mergeCall,
               enclosingNode,
               parentScope);
       registerNamespace(usingScope, null, mergeNs, forceNullable);
       registerQuery(
           parentScope,
           usingScope,
           mergeCall.getSourceSelect(),
           enclosingNode,
           null,
           false);
 
       // update call can reference either the source table reference
       // or the target table, so set its parent scope to the merge's
       // source select; when validating the update, skip the feature
       // validation check
       if (mergeCall.getUpdateCall() != null) {
         registerQuery(
             clauseScopes.get(IdPair.of(mergeCall.getSourceSelect(), Clause.WHERE)),
             null,
             mergeCall.getUpdateCall(),
             enclosingNode,
             null,
             false,
             false);
       }
       if (mergeCall.getInsertCall() != null) {
         registerQuery(
             parentScope,
             null,
             mergeCall.getInsertCall(),
             enclosingNode,
             null,
             false);
       }
       break;
 
     case UNNEST:
       call = (SqlCall) node;
       final UnnestNamespace unnestNs =
           new UnnestNamespace(this, call, parentScope, enclosingNode);
       registerNamespace(
           usingScope,
           alias,
           unnestNs,
           forceNullable);
       registerOperandSubQueries(parentScope, call, 0);
       scopes.put(node, parentScope);
       break;
     case OTHER_FUNCTION:
       call = (SqlCall) node;
       ProcedureNamespace procNs =
           new ProcedureNamespace(
               this,
               parentScope,
               call,
               enclosingNode);
       registerNamespace(
           usingScope,
           alias,
           procNs,
           forceNullable);
       registerSubQueries(parentScope, call);
       break;
 
     case MULTISET_QUERY_CONSTRUCTOR:
     case MULTISET_VALUE_CONSTRUCTOR:
       validateFeature(RESOURCE.sQLFeature_S271(), node.getParserPosition());
       call = (SqlCall) node;
       CollectScope cs = new CollectScope(parentScope, usingScope, call);
       final CollectNamespace tableConstructorNs =
           new CollectNamespace(call, cs, enclosingNode);
       final String alias2 = deriveAlias(node, nextGeneratedId++);
       registerNamespace(
           usingScope,
           alias2,
           tableConstructorNs,
           forceNullable);
       operands = call.getOperandList();
       for (int i = 0; i < operands.size(); i++) {
         registerOperandSubQueries(parentScope, call, i);
       }
       break;
 
     default:
       throw Util.unexpected(node.getKind());
     }
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerSetop	(	SqlValidatorScope	parentScope,
		SqlValidatorScope	usingScope,
		SqlNode	node,
		SqlNode	enclosingNode,
		String	alias,
		boolean	forceNullable
	)

inlineprivate

Definition at line 2839 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.createSetopNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerNamespace(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

                              {
     SqlCall call = (SqlCall) node;
     final SetopNamespace setopNamespace =
         createSetopNamespace(call, enclosingNode);
     registerNamespace(usingScope, alias, setopNamespace, forceNullable);
 
     // A setop is in the same scope as its parent.
     scopes.put(call, parentScope);
     for (SqlNode operand : call.getOperandList()) {
       registerQuery(
           parentScope,
           null,
           operand,
           operand,
           null,
           false);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerSubQueries	(	SqlValidatorScope	parentScope,
		SqlNode	node
	)

inlineprivate

Definition at line 2966 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.registerOperandSubQueries(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateNodeFeature().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerOperandSubQueries(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

                     {
     if (node == null) {
       return;
     }
     if (node.getKind().belongsTo(SqlKind.QUERY)
         || node.getKind() == SqlKind.MULTISET_QUERY_CONSTRUCTOR
         || node.getKind() == SqlKind.MULTISET_VALUE_CONSTRUCTOR) {
       registerQuery(parentScope, null, node, node, null, false);
     } else if (node instanceof SqlCall) {
       validateNodeFeature(node);
       SqlCall call = (SqlCall) node;
       for (int i = 0; i < call.operandCount(); i++) {
         registerOperandSubQueries(parentScope, call, i);
       }
     } else if (node instanceof SqlNodeList) {
       SqlNodeList list = (SqlNodeList) node;
       for (int i = 0, count = list.size(); i < count; i++) {
         SqlNode listNode = list.get(i);
         if (listNode.getKind().belongsTo(SqlKind.QUERY)) {
           listNode =
               SqlStdOperatorTable.SCALAR_QUERY.createCall(
                   listNode.getParserPosition(),
                   listNode);
           list.set(i, listNode);
         }
         registerSubQueries(parentScope, listNode);
       }
     } else {
       // atomic node -- can be ignored
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.registerWith	(	SqlValidatorScope	parentScope,
		SqlValidatorScope	usingScope,
		SqlWith	with,
		SqlNode	enclosingNode,
		String	alias,
		boolean	forceNullable,
		boolean	checkUpdate
	)

inlineprivate

Definition at line 2864 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.registerNamespace(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

                            {
     final WithNamespace withNamespace =
         new WithNamespace(this, with, enclosingNode);
     registerNamespace(usingScope, alias, withNamespace, forceNullable);
 
     SqlValidatorScope scope = parentScope;
     for (SqlNode withItem_ : with.withList) {
       final SqlWithItem withItem = (SqlWithItem) withItem_;
       final WithScope withScope = new WithScope(scope, withItem);
       scopes.put(withItem, withScope);
 
       registerQuery(scope, null, withItem.query, with,
           withItem.name.getSimple(), false);
       registerNamespace(null, alias,
           new WithItemNamespace(this, withItem, enclosingNode),
           false);
       scope = withScope;
     }
 
     registerQuery(scope, null, with.body, enclosingNode, alias, forceNullable,
         checkUpdate);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.removeValidatedNodeType ( SqlNode node )

inline

Definition at line 1733 of file SqlValidatorImpl.java.

                                                     {
     nodeToTypeMap.remove(node);
   }

SqlWindow org.apache.calcite.sql.validate.SqlValidatorImpl.resolveWindow	(	SqlNode	windowOrRef,
		SqlValidatorScope	scope
	)

inline

Definition at line 5053 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getWindowByName(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

                                {
     SqlWindow window;
     if (windowOrRef instanceof SqlIdentifier) {
       window = getWindowByName((SqlIdentifier) windowOrRef, scope);
     } else {
       window = (SqlWindow) windowOrRef;
     }
     while (true) {
       final SqlIdentifier refId = window.getRefName();
       if (refId == null) {
         break;
       }
       final String refName = refId.getSimple();
       SqlWindow refWindow = scope.lookupWindow(refName);
       if (refWindow == null) {
         throw newValidationError(refId, RESOURCE.windowNotFound(refName));
       }
       window = window.overlay(refWindow, this);
     }
 
     return window;
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteMerge ( SqlMerge call )

inlineprivate

Definition at line 1448 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), and org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteUpdateToMerge().

                                            {
     SqlNodeList selectList;
     SqlUpdate updateStmt = call.getUpdateCall();
     if (updateStmt != null) {
       // if we have an update statement, just clone the select list
       // from the update statement's source since it's the same as
       // what we want for the select list of the merge source -- '*'
       // followed by the update set expressions
       selectList = SqlNode.clone(updateStmt.getSourceSelect().getSelectList());
     } else {
       // otherwise, just use select *
       selectList = new SqlNodeList(SqlParserPos.ZERO);
       selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
     }
     SqlNode targetTable = call.getTargetTable();
     if (call.getAlias() != null) {
       targetTable =
           SqlValidatorUtil.addAlias(
               targetTable,
               call.getAlias().getSimple());
     }
 
     // Provided there is an insert substatement, the source select for
     // the merge is a left outer join between the source in the USING
     // clause and the target table; otherwise, the join is just an
     // inner join.  Need to clone the source table reference in order
     // for validation to work
     SqlNode sourceTableRef = call.getSourceTableRef();
     SqlInsert insertCall = call.getInsertCall();
     JoinType joinType = (insertCall == null) ? JoinType.INNER : JoinType.LEFT;
     final SqlNode leftJoinTerm = SqlNode.clone(sourceTableRef);
     SqlNode outerJoin =
         new SqlJoin(SqlParserPos.ZERO,
             leftJoinTerm,
             SqlLiteral.createBoolean(false, SqlParserPos.ZERO),
             joinType.symbol(SqlParserPos.ZERO),
             targetTable,
             JoinConditionType.ON.symbol(SqlParserPos.ZERO),
             call.getCondition());
     SqlSelect select =
         new SqlSelect(SqlParserPos.ZERO, null, selectList, outerJoin, null,
             null, null, null, null, null, null, null);
     call.setSourceSelect(select);
 
     // Source for the insert call is a select of the source table
     // reference with the select list being the value expressions;
     // note that the values clause has already been converted to a
     // select on the values row constructor; so we need to extract
     // that via the from clause on the select
     if (insertCall != null) {
       SqlCall valuesCall = (SqlCall) insertCall.getSource();
       SqlCall rowCall = valuesCall.operand(0);
       selectList =
           new SqlNodeList(
               rowCall.getOperandList(),
               SqlParserPos.ZERO);
       final SqlNode insertSource = SqlNode.clone(sourceTableRef);
       select =
           new SqlSelect(SqlParserPos.ZERO, null, selectList, insertSource, null,
               null, null, null, null, null, null, null);
       insertCall.setSource(select);
     }
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteUpdateToMerge	(	SqlUpdate	updateCall,
		SqlNode	selfJoinSrcExpr
	)

inlineprivate

Definition at line 1512 of file SqlValidatorImpl.java.

References field(), org.apache.calcite.sql.validate.SqlValidatorImpl.getSelfJoinExprForUpdate(), org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteMerge(), org.apache.calcite.sql.validate.SqlValidatorImpl.UPDATE_ANON_PREFIX, org.apache.calcite.sql.validate.SqlValidatorImpl.UPDATE_SRC_ALIAS, and org.apache.calcite.sql.validate.SqlValidatorImpl.UPDATE_TGT_ALIAS.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites().

                                {
     // Make sure target has an alias.
     if (updateCall.getAlias() == null) {
       updateCall.setAlias(
           new SqlIdentifier(UPDATE_TGT_ALIAS, SqlParserPos.ZERO));
     }
     SqlNode selfJoinTgtExpr =
         getSelfJoinExprForUpdate(
             updateCall.getTargetTable(),
             updateCall.getAlias().getSimple());
     assert selfJoinTgtExpr != null;
 
     // Create join condition between source and target exprs,
     // creating a conjunction with the user-level WHERE
     // clause if one was supplied
     SqlNode condition = updateCall.getCondition();
     SqlNode selfJoinCond =
         SqlStdOperatorTable.EQUALS.createCall(
             SqlParserPos.ZERO,
             selfJoinSrcExpr,
             selfJoinTgtExpr);
     if (condition == null) {
       condition = selfJoinCond;
     } else {
       condition =
           SqlStdOperatorTable.AND.createCall(
               SqlParserPos.ZERO,
               selfJoinCond,
               condition);
     }
     SqlNode target =
         updateCall.getTargetTable().clone(SqlParserPos.ZERO);
 
     // For the source, we need to anonymize the fields, so
     // that for a statement like UPDATE T SET I = I + 1,
     // there's no ambiguity for the "I" in "I + 1";
     // this is OK because the source and target have
     // identical values due to the self-join.
     // Note that we anonymize the source rather than the
     // target because downstream, the optimizer rules
     // don't want to see any projection on top of the target.
     IdentifierNamespace ns =
         new IdentifierNamespace(this, target, null, null);
     RelDataType rowType = ns.getRowType();
     SqlNode source = updateCall.getTargetTable().clone(SqlParserPos.ZERO);
     final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
     int i = 1;
     for (RelDataTypeField field : rowType.getFieldList()) {
       SqlIdentifier col =
           new SqlIdentifier(
               field.getName(),
               SqlParserPos.ZERO);
       selectList.add(
           SqlValidatorUtil.addAlias(col, UPDATE_ANON_PREFIX + i));
       ++i;
     }
     source =
         new SqlSelect(SqlParserPos.ZERO, null, selectList, source, null, null,
             null, null, null, null, null, null);
     source = SqlValidatorUtil.addAlias(source, UPDATE_SRC_ALIAS);
     SqlMerge mergeCall =
         new SqlMerge(updateCall.getParserPosition(), target, condition, source,
             updateCall, null, null, updateCall.getAlias());
     rewriteMerge(mergeCall);
     return mergeCall;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.setOriginal	(	SqlNode	expr,
		SqlNode	original
	)

inline

Definition at line 5086 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expand(), org.apache.calcite.sql.validate.SqlValidatorImpl.expandGroupByOrHavingExpr(), org.apache.calcite.sql.validate.SqlValidatorImpl.expandSelectExpr(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateDefinitions(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateMeasure().

                                                           {
     // Don't overwrite the original original.
     originalExprs.putIfAbsent(expr, original);
   }

Here is the caller graph for this function:

final void org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType	(	SqlNode	node,
		RelDataType	type
	)

inline

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

Unlike the base class method, this method is not deprecated. It is available from within Calcite, but is not part of the public API.

Parameters

node	A SQL parse tree node, never null
type	Its type; must not be null

Definition at line 1722 of file SqlValidatorImpl.java.

References run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType.

                                                                          {
     Objects.requireNonNull(type);
     Objects.requireNonNull(node);
     if (type.equals(unknownType)) {
       // don't set anything until we know what it is, and don't overwrite
       // a known type with the unknown type
       return;
     }
     nodeToTypeMap.put(node, type);
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.shouldAllowIntermediateOrderBy ( )

inlineprotected

Definition at line 2008 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderList().

                                                      {
     return true;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.shouldAllowOverRelation ( )

inlineprotected

Definition at line 2451 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom().

                                               {
     return false;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.shouldCheckForRollUp ( SqlNode from )

inlineprivate

Definition at line 3643 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                      {
     if (from != null) {
       SqlKind kind = stripAs(from).getKind();
       return kind != SqlKind.VALUES && kind != SqlKind.SELECT;
     }
     return false;
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.stripDot ( SqlNode node )

inlineprivate

Definition at line 3528 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp().

                                          {
     if (node != null && node.getKind() == SqlKind.DOT) {
       return stripDot(((SqlCall) node).operand(0));
     }
     return node;
   }

Here is the caller graph for this function:

static SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.stripOver ( SqlNode node )

inlinestaticprivate

Definition at line 3577 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.checkRollUp().

                                                  {
     switch (node.getKind()) {
     case OVER:
       return ((SqlCall) node).getOperandList().get(0);
     default:
       return node;
     }
   }

Here is the caller graph for this function:

SqlValidator org.apache.calcite.sql.validate.SqlValidatorImpl.transform ( UnaryOperator< Config > transform )

inline

Definition at line 3919 of file SqlValidatorImpl.java.

                                                                  {
     this.config = transform.apply(this.config);
     return this;
   }

List<String> org.apache.calcite.sql.validate.SqlValidatorImpl.usingNames ( SqlJoin join )

inline

Returns the set of field names in the join condition specified by USING or implicitly by NATURAL, de-duplicated and in order.

Definition at line 520 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType(), setup.name, and NONE.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.Permute.Permute().

                                                {
     switch (join.getConditionType()) {
     case USING:
       final ImmutableList.Builder<String> list = ImmutableList.builder();
       final Set<String> names = catalogReader.nameMatcher().createSet();
       for (SqlNode node : (SqlNodeList) join.getCondition()) {
         final String name = ((SqlIdentifier) node).getSimple();
         if (names.add(name)) {
           list.add(name);
         }
       }
       return list.build();
     case NONE:
       if (join.isNatural()) {
         final RelDataType t0 = getValidatedNodeType(join.getLeft());
         final RelDataType t1 = getValidatedNodeType(join.getRight());
         return SqlValidatorUtil.deriveNaturalJoinColumnList(
             catalogReader.nameMatcher(), t0, t1);
       }
     }
     return null;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.validate ( SqlNode topNode )

inline

Definition at line 751 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType(), run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.validateScopedExpression().

                                            {
     SqlValidatorScope scope = new EmptyScope(this);
     scope = new CatalogScope(scope, ImmutableList.of("CATALOG"));
     final SqlNode topNode2 = validateScopedExpression(topNode, scope);
     final RelDataType type = getValidatedNodeType(topNode2);
     Util.discard(type);
     return topNode2;
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateAccess	(	SqlNode	node,
		SqlValidatorTable	table,
		SqlAccessEnum	requiredAccess
	)

inlineprivate

Validates access to a table.

Parameters

table	Table
requiredAccess	Access requested on table

Definition at line 4849 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and toString().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateDelete(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

                                     {
     if (table != null) {
       SqlAccessType access = table.getAllowedAccess();
       if (!access.allowsAccess(requiredAccess)) {
         throw newValidationError(node,
             RESOURCE.accessNotAllowed(requiredAccess.name(),
                 table.getQualifiedName().toString()));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateAggregateParams	(	SqlCall	aggCall,
		SqlNode	filter,
		SqlNodeList	orderList,
		SqlValidatorScope	scope
	)

inline

Definition at line 5399 of file SqlValidatorImpl.java.

References anonymous_namespace{Utm.h}.a, org.apache.calcite.sql.validate.SqlValidatorImpl.aggOrOverFinder, org.apache.calcite.sql.validate.SqlValidatorImpl.inWindow, org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and org.apache.calcite.sql.validate.SqlValidatorImpl.overFinder.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateWindow().

                                                       {
     // For "agg(expr)", expr cannot itself contain aggregate function
     // invocations.  For example, "SUM(2 * MAX(x))" is illegal; when
     // we see it, we'll report the error for the SUM (not the MAX).
     // For more than one level of nesting, the error which results
     // depends on the traversal order for validation.
     //
     // For a windowed aggregate "agg(expr)", expr can contain an aggregate
     // function. For example,
     //   SELECT AVG(2 * MAX(x)) OVER (PARTITION BY y)
     //   FROM t
     //   GROUP BY y
     // is legal. Only one level of nesting is allowed since non-windowed
     // aggregates cannot nest aggregates.
 
     // Store nesting level of each aggregate. If an aggregate is found at an invalid
     // nesting level, throw an assert.
     final AggFinder a;
     if (inWindow) {
       a = overFinder;
     } else {
       a = aggOrOverFinder;
     }
 
     for (SqlNode param : aggCall.getOperandList()) {
       if (a.findAgg(param) != null) {
         throw newValidationError(aggCall, RESOURCE.nestedAggIllegal());
       }
     }
     if (filter != null) {
       if (a.findAgg(filter) != null) {
         throw newValidationError(filter, RESOURCE.aggregateInFilterIllegal());
       }
     }
     if (orderList != null) {
       for (SqlNode param : orderList) {
         if (a.findAgg(param) != null) {
           throw newValidationError(aggCall,
               RESOURCE.aggregateInWithinGroupIllegal());
         }
       }
     }
 
     final SqlAggFunction op = (SqlAggFunction) aggCall.getOperator();
     switch (op.requiresGroupOrder()) {
     case MANDATORY:
       if (orderList == null || orderList.size() == 0) {
         throw newValidationError(aggCall,
             RESOURCE.aggregateMissingWithinGroupClause(op.getName()));
       }
       break;
     case OPTIONAL:
       break;
     case IGNORED:
       // rewrite the order list to empty
       if (orderList != null) {
         orderList.getList().clear();
       }
       break;
     case FORBIDDEN:
       if (orderList != null && orderList.size() != 0) {
         throw newValidationError(aggCall,
             RESOURCE.withinGroupClauseIllegalInAggregate(op.getName()));
       }
       break;
     default:
       throw new AssertionError(op);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateCall	(	SqlCall	call,
		SqlValidatorScope	scope
	)

inline

Definition at line 5470 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.handleUnresolvedFunction(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

                                {
     final SqlOperator operator = call.getOperator();
     if ((call.operandCount() == 0)
         && (operator.getSyntax() == SqlSyntax.FUNCTION_ID)
         && !call.isExpanded()
         && !this.config.sqlConformance().allowNiladicParentheses()) {
       // For example, "LOCALTIME()" is illegal. (It should be
       // "LOCALTIME", which would have been handled as a
       // SqlIdentifier.)
       throw handleUnresolvedFunction(call, (SqlFunction) operator,
           ImmutableList.of(), null);
     }
 
     SqlValidatorScope operandScope = scope.getOperandScope(call);
 
     if (operator instanceof SqlFunction
         && ((SqlFunction) operator).getFunctionType()
             == SqlFunctionCategory.MATCH_RECOGNIZE
         && !(operandScope instanceof MatchRecognizeScope)) {
       throw newValidationError(call,
           Static.RESOURCE.functionMatchRecognizeOnly(call.toString()));
     }
     // Delegate validation to the operator.
     operator.validateCall(call, this, scope, operandScope);
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateColumnListParams	(	SqlFunction	function,
		List< RelDataType >	argTypes,
		List< SqlNode >	operands
	)

inline

Definition at line 5628 of file SqlValidatorImpl.java.

                               {
     throw new UnsupportedOperationException();
   }

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateDataType ( SqlDataTypeSpec dataType )

inline

Definition at line 4990 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.DeriveTypeVisitor.visit().

4990 {

4991 }

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateDefinitions	(	SqlMatchRecognize	mr,
		MatchRecognizeScope	scope
	)

inlineprivate

Definition at line 5336 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateMatchRecognize().

                                  {
     final Set<String> aliases = catalogReader.nameMatcher().createSet();
     for (SqlNode item : mr.getPatternDefList().getList()) {
       final String alias = alias(item);
       if (!aliases.add(alias)) {
         throw newValidationError(item,
             Static.RESOURCE.patternVarAlreadyDefined(alias));
       }
       scope.addPatternVar(alias);
     }
 
     final List<SqlNode> sqlNodes = new ArrayList<>();
     for (SqlNode item : mr.getPatternDefList().getList()) {
       final String alias = alias(item);
       SqlNode expand = expand(item, scope);
       expand = navigationInDefine(expand, alias);
       setOriginal(expand, item);
 
       inferUnknownTypes(booleanType, scope, expand);
       expand.validate(this, scope);
 
       // Some extra work need required here.
       // In PREV, NEXT, FINAL and LAST, only one pattern variable is allowed.
       sqlNodes.add(
           SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO, expand,
               new SqlIdentifier(alias, SqlParserPos.ZERO)));
 
       final RelDataType type = deriveType(scope, expand);
       if (!SqlTypeUtil.inBooleanFamily(type)) {
         throw newValidationError(expand, RESOURCE.condMustBeBoolean("DEFINE"));
       }
       setValidatedNodeType(item, type);
     }
 
     SqlNodeList list =
         new SqlNodeList(sqlNodes, mr.getPatternDefList().getParserPosition());
     inferUnknownTypes(unknownType, scope, list);
     for (SqlNode node : list) {
       validateExpr(node, scope);
     }
     mr.setOperand(SqlMatchRecognize.OPERAND_PATTERN_DEFINES, list);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateDelete ( SqlDelete call )

inline

Definition at line 4756 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType, org.apache.calcite.sql.validate.SqlValidatorImpl.validateAccess(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateNamespace(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                              {
     final SqlSelect sqlSelect = call.getSourceSelect();
     validateSelect(sqlSelect, unknownType);
 
     final SqlValidatorNamespace targetNamespace = getNamespace(call);
     validateNamespace(targetNamespace, unknownType);
     final SqlValidatorTable table = targetNamespace.getTable();
 
     validateAccess(call.getTargetTable(), table, SqlAccessEnum.DELETE);
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateDynamicParam ( SqlDynamicParam dynamicParam )

inline

Definition at line 4993 of file SqlValidatorImpl.java.

4993 {

4994 }

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateExpr	(	SqlNode	expr,
		SqlValidatorScope	scope
	)

inlineprivate

Validates an expression.

Parameters

expr	Expression
scope	Scope in which expression occurs

Definition at line 4239 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.SqlOperator.isAggregator(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateDefinitions(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupByExpr(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateMeasure(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderItem(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList().

                                                                    {
     if (expr instanceof SqlCall) {
       final SqlOperator op = ((SqlCall) expr).getOperator();
       if (op.isAggregator() && op.requiresOver()) {
         throw newValidationError(expr,
             RESOURCE.absentOverClause());
       }
       if (op instanceof SqlTableFunction) {
         throw RESOURCE.cannotCallTableFunctionHere(op.getName()).ex();
       }
     }
 
     // Call on the expression to validate itself.
     expr.validateExpr(this, scope);
 
     // Perform any validation specific to the scope. For example, an
     // aggregating scope requires that expressions are valid aggregations.
     scope.validateExpr(expr);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateFeature	(	Feature	feature,
		SqlParserPos	context
	)

inlineprotected

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 instance
context	parser position context for error reporting, or null if

Definition at line 5506 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateNodeFeature(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderItem(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                             {
     // By default, do nothing except to verify that the resource
     // represents a real feature definition.
     assert feature.getProperties().get("FeatureDefinition") != null;
   }

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateFrom	(	SqlNode	node,
		RelDataType	targetRowType,
		SqlValidatorScope	scope
	)

inlineprotected

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

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

Definition at line 3172 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateOver(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateUnnest(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateValues().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                {
     Objects.requireNonNull(targetRowType);
     switch (node.getKind()) {
     case AS:
     case TABLE_REF:
       validateFrom(
           ((SqlCall) node).operand(0),
           targetRowType,
           scope);
       break;
     case VALUES:
       validateValues((SqlCall) node, targetRowType, scope);
       break;
     case JOIN:
       validateJoin((SqlJoin) node, scope);
       break;
     case OVER:
       validateOver((SqlCall) node, scope);
       break;
     case UNNEST:
       validateUnnest((SqlCall) node, scope, targetRowType);
       break;
     default:
       validateQuery(node, scope, targetRowType);
       break;
     }
 
     // Validate the namespace representation of the node, just in case the
     // validation did not occur implicitly.
     getNamespace(node, scope).validate(targetRowType);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupByExpr	(	SqlNode	groupByItem,
		SqlValidatorScope	groupByScope
	)

inlineprivate

Definition at line 3973 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.validateExpr().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupByItem().

                                       {
     switch (groupByItem.getKind()) {
     case GROUPING_SETS:
     case ROLLUP:
     case CUBE:
       final SqlCall call = (SqlCall) groupByItem;
       for (SqlNode operand : call.getOperandList()) {
         validateExpr(operand, groupByScope);
       }
       break;
     default:
       validateExpr(groupByItem, groupByScope);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupByItem	(	SqlSelect	select,
		SqlNode	groupByItem
	)

inlineprivate

Validates an item in the GROUP BY clause of a SELECT statement.

Parameters

select	Select statement
groupByItem	GROUP BY clause item

Definition at line 3967 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getGroupScope(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupByExpr().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause().

                                                                           {
     final SqlValidatorScope groupByScope = getGroupScope(select);
     validateGroupByExpr(groupByItem, groupByScope);
     groupByScope.validateExpr(groupByItem);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause ( SqlSelect select )

inlineprotected

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

Definition at line 4025 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                        {
     SqlNodeList groupList = select.getGroup();
     if (groupList == null) {
       return;
     }
     final String clause = "GROUP BY";
     validateNoAggs(aggOrOverFinder, groupList, clause);
     final SqlValidatorScope groupScope = getGroupScope(select);
     inferUnknownTypes(unknownType, groupScope, groupList);
 
     // expand the expression in group list.
     List<SqlNode> expandedList = new ArrayList<>();
     for (SqlNode groupItem : groupList) {
       SqlNode expandedItem = expandGroupByOrHavingExpr(groupItem, groupScope, select, false);
       expandedList.add(expandedItem);
     }
     groupList = new SqlNodeList(expandedList, groupList.getParserPosition());
     select.setGroupBy(groupList);
     for (SqlNode groupItem : expandedList) {
       validateGroupByItem(select, groupItem);
     }
 
     // Nodes in the GROUP BY clause are expressions except if they are calls
     // to the GROUPING SETS, ROLLUP or CUBE operators; this operators are not
     // expressions, because they do not have a type.
     for (SqlNode node : groupList) {
       switch (node.getKind()) {
       case GROUPING_SETS:
       case ROLLUP:
       case CUBE:
         node.validate(this, groupScope);
         break;
       default:
         node.validateExpr(this, groupScope);
       }
     }
 
     // Derive the type of each GROUP BY item. We don't need the type, but
     // it resolves functions, and that is necessary for deducing
     // monotonicity.
     final SqlValidatorScope selectScope = getSelectScope(select);
     AggregatingSelectScope aggregatingScope = null;
     if (selectScope instanceof AggregatingSelectScope) {
       aggregatingScope = (AggregatingSelectScope) selectScope;
     }
     for (SqlNode groupItem : groupList) {
       if (groupItem instanceof SqlNodeList
           && ((SqlNodeList) groupItem).size() == 0) {
         continue;
       }
       validateGroupItem(groupScope, aggregatingScope, groupItem);
     }
 
     SqlNode agg = aggFinder.findAgg(groupList);
     if (agg != null) {
       throw newValidationError(agg, RESOURCE.aggregateIllegalInClause(clause));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupingSets	(	SqlValidatorScope	groupScope,
		AggregatingSelectScope	aggregatingScope,
		SqlCall	groupItem
	)

inlineprivate

Definition at line 4102 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupItem().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupItem().

                                                                   {
     for (SqlNode node : groupItem.getOperandList()) {
       validateGroupItem(groupScope, aggregatingScope, node);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupItem	(	SqlValidatorScope	groupScope,
		AggregatingSelectScope	aggregatingScope,
		SqlNode	groupItem
	)

inlineprivate

Definition at line 4084 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType(), run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupingSets().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupingSets().

                          {
     switch (groupItem.getKind()) {
     case GROUPING_SETS:
     case ROLLUP:
     case CUBE:
       validateGroupingSets(groupScope, aggregatingScope, (SqlCall) groupItem);
       break;
     default:
       if (groupItem instanceof SqlNodeList) {
         break;
       }
       final RelDataType type = deriveType(groupScope, groupItem);
       setValidatedNodeType(groupItem, type);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateHavingClause ( SqlSelect select )

inlineprotected

Definition at line 4138 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.booleanType, org.apache.calcite.sql.validate.SqlValidatorImpl.config(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.expandGroupByOrHavingExpr(), org.apache.calcite.sql.validate.SqlValidatorImpl.getSelectScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.inferUnknownTypes(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and run_benchmark_import.type.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                         {
     // HAVING is validated in the scope after groups have been created.
     // For example, in "SELECT empno FROM emp WHERE empno = 10 GROUP BY
     // deptno HAVING empno = 10", the reference to 'empno' in the HAVING
     // clause is illegal.
     SqlNode having = select.getHaving();
     if (having == null) {
       return;
     }
     final AggregatingScope havingScope =
         (AggregatingScope) getSelectScope(select);
     if (config.sqlConformance().isHavingAlias()) {
       SqlNode newExpr = expandGroupByOrHavingExpr(having, havingScope, select, true);
       if (having != newExpr) {
         having = newExpr;
         select.setHaving(newExpr);
       }
     }
     havingScope.checkAggregateExpr(having, true);
     inferUnknownTypes(
         booleanType,
         havingScope,
         having);
     having.validate(this, havingScope);
     final RelDataType type = deriveType(havingScope, having);
     if (!SqlTypeUtil.inBooleanFamily(type)) {
       throw newValidationError(having, RESOURCE.havingMustBeBoolean());
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateIdentifier	(	SqlIdentifier	id,
		SqlValidatorScope	scope
	)

inline

Definition at line 3028 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.config().

                                                                             {
     final SqlQualified fqId = scope.fullyQualify(id);
     if (this.config.columnReferenceExpansion()) {
       // NOTE jvs 9-Apr-2007: this doesn't cover ORDER BY, which has its
       // own ideas about qualification.
       id.assignNamesFrom(fqId.identifier);
     } else {
       Util.discard(fqId);
     }
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert ( SqlInsert insert )

inline

Definition at line 4354 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge().

                                                {
     final SqlValidatorNamespace targetNamespace = getNamespace(insert);
     validateNamespace(targetNamespace, unknownType);
     final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
         targetNamespace, catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
     final SqlValidatorTable table = relOptTable == null
         ? targetNamespace.getTable()
         : relOptTable.unwrap(SqlValidatorTable.class);
 
     // INSERT has an optional column name list.  If present then
     // reduce the rowtype to the columns specified.  If not present
     // then the entire target rowtype is used.
     final RelDataType targetRowType =
         createTargetRowType(
             table,
             insert.getTargetColumnList(),
             false);
 
     final SqlNode source = insert.getSource();
     if (source instanceof SqlSelect) {
       final SqlSelect sqlSelect = (SqlSelect) source;
       validateSelect(sqlSelect, targetRowType);
     } else {
       final SqlValidatorScope scope = scopes.get(source);
       validateQuery(source, scope, targetRowType);
     }
 
     // REVIEW jvs 4-Dec-2008: In FRG-365, this namespace row type is
     // discarding the type inferred by inferUnknownTypes (which was invoked
     // from validateSelect above).  It would be better if that information
     // were used here so that we never saw any untyped nulls during
     // checkTypeAssignment.
     final RelDataType sourceRowType = getNamespace(source).getRowType();
     final RelDataType logicalTargetRowType =
         getLogicalTargetRowType(targetRowType, insert);
     setValidatedNodeType(insert, logicalTargetRowType);
     final RelDataType logicalSourceRowType =
         getLogicalSourceRowType(sourceRowType, insert);
 
     final List<ColumnStrategy> strategies =
         table.unwrap(RelOptTable.class).getColumnStrategies();
 
     final RelDataType realTargetRowType = typeFactory.createStructType(
         logicalTargetRowType.getFieldList()
             .stream().filter(f -> strategies.get(f.getIndex()).canInsertInto())
             .collect(Collectors.toList()));
 
     final RelDataType targetRowTypeToValidate =
         logicalSourceRowType.getFieldCount() == logicalTargetRowType.getFieldCount()
         ? logicalTargetRowType
         : realTargetRowType;
 
     checkFieldCount(insert.getTargetTable(), table, strategies,
         targetRowTypeToValidate, realTargetRowType,
         source, logicalSourceRowType, logicalTargetRowType);
 
     checkTypeAssignment(scopes.get(source),
         table,
         logicalSourceRowType,
         targetRowTypeToValidate,
         insert);
 
     checkConstraint(table, source, logicalTargetRowType);
 
     validateAccess(insert.getTargetTable(), table, SqlAccessEnum.INSERT);
 
     // Refresh the insert row type to keep sync with source.
     setValidatedNodeType(insert, targetRowTypeToValidate);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateIntervalQualifier ( SqlIntervalQualifier qualifier )

inline

Definition at line 3129 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateLiteral().

                                                                         {
     assert qualifier != null;
     boolean startPrecisionOutOfRange = false;
     boolean fractionalSecondPrecisionOutOfRange = false;
     final RelDataTypeSystem typeSystem = typeFactory.getTypeSystem();
 
     final int startPrecision = qualifier.getStartPrecision(typeSystem);
     final int fracPrecision =
         qualifier.getFractionalSecondPrecision(typeSystem);
     final int maxPrecision = typeSystem.getMaxPrecision(qualifier.typeName());
     final int minPrecision = qualifier.typeName().getMinPrecision();
     final int minScale = qualifier.typeName().getMinScale();
     final int maxScale = typeSystem.getMaxScale(qualifier.typeName());
     if (startPrecision < minPrecision || startPrecision > maxPrecision) {
       startPrecisionOutOfRange = true;
     } else {
       if (fracPrecision < minScale || fracPrecision > maxScale) {
         fractionalSecondPrecisionOutOfRange = true;
       }
     }
 
     if (startPrecisionOutOfRange) {
       throw newValidationError(qualifier,
           RESOURCE.intervalStartPrecisionOutOfRange(startPrecision,
               "INTERVAL " + qualifier));
     } else if (fractionalSecondPrecisionOutOfRange) {
       throw newValidationError(qualifier,
           RESOURCE.intervalFractionalSecondPrecisionOutOfRange(
               fracPrecision,
               "INTERVAL " + qualifier));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin	(	SqlJoin	join,
		SqlValidatorScope	scope
	)

inlineprotected

Definition at line 3236 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateFrom().

                                                                      {
     SqlNode left = join.getLeft();
     SqlNode right = join.getRight();
     SqlNode condition = join.getCondition();
     boolean natural = join.isNatural();
     final JoinType joinType = join.getJoinType();
     final JoinConditionType conditionType = join.getConditionType();
     final SqlValidatorScope joinScope = scopes.get(join);
     validateFrom(left, unknownType, joinScope);
     validateFrom(right, unknownType, joinScope);
 
     // Validate condition.
     switch (conditionType) {
     case NONE:
       Preconditions.checkArgument(condition == null);
       break;
     case ON:
       Preconditions.checkArgument(condition != null);
       SqlNode expandedCondition = expand(condition, joinScope);
       join.setOperand(5, expandedCondition);
       condition = join.getCondition();
       validateWhereOrOn(joinScope, condition, "ON");
       checkRollUp(null, join, condition, joinScope, "ON");
       break;
     case USING:
       SqlNodeList list = (SqlNodeList) condition;
 
       // Parser ensures that using clause is not empty.
       Preconditions.checkArgument(list.size() > 0, "Empty USING clause");
       for (SqlNode node : list) {
         SqlIdentifier id = (SqlIdentifier) node;
         final RelDataType leftColType = validateUsingCol(id, left);
         final RelDataType rightColType = validateUsingCol(id, right);
         if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
           throw newValidationError(id,
               RESOURCE.naturalOrUsingColumnNotCompatible(id.getSimple(),
                   leftColType.toString(), rightColType.toString()));
         }
         checkRollUpInUsing(id, left, scope);
         checkRollUpInUsing(id, right, scope);
       }
       break;
     default:
       throw Util.unexpected(conditionType);
     }
 
     // Validate NATURAL.
     if (natural) {
       if (condition != null) {
         throw newValidationError(condition,
             RESOURCE.naturalDisallowsOnOrUsing());
       }
 
       // Join on fields that occur exactly once on each side. Ignore
       // fields that occur more than once on either side.
       final RelDataType leftRowType = getNamespace(left).getRowType();
       final RelDataType rightRowType = getNamespace(right).getRowType();
       final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
       List<String> naturalColumnNames =
           SqlValidatorUtil.deriveNaturalJoinColumnList(nameMatcher,
               leftRowType, rightRowType);
 
       // Check compatibility of the chosen columns.
       for (String name : naturalColumnNames) {
         final RelDataType leftColType =
             nameMatcher.field(leftRowType, name).getType();
         final RelDataType rightColType =
             nameMatcher.field(rightRowType, name).getType();
         if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
           throw newValidationError(join,
               RESOURCE.naturalOrUsingColumnNotCompatible(name,
                   leftColType.toString(), rightColType.toString()));
         }
       }
     }
 
     // Which join types require/allow a ON/USING condition, or allow
     // a NATURAL keyword?
     switch (joinType) {
     case LEFT_SEMI_JOIN:
       if (!this.config.sqlConformance().isLiberal()) {
         throw newValidationError(join.getJoinTypeNode(),
             RESOURCE.dialectDoesNotSupportFeature("LEFT SEMI JOIN"));
       }
       // fall through
     case INNER:
     case LEFT:
     case RIGHT:
     case FULL:
       if ((condition == null) && !natural) {
         throw newValidationError(join, RESOURCE.joinRequiresCondition());
       }
       break;
     case COMMA:
     case CROSS:
       if (condition != null) {
         throw newValidationError(join.getConditionTypeNode(),
             RESOURCE.crossJoinDisallowsCondition());
       }
       if (natural) {
         throw newValidationError(join.getConditionTypeNode(),
             RESOURCE.crossJoinDisallowsCondition());
       }
       break;
     default:
       throw Util.unexpected(joinType);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateLiteral ( SqlLiteral literal )

inline

Definition at line 3039 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory, org.apache.calcite.sql.validate.SqlValidatorImpl.validateIntervalQualifier(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateLiteralAsDouble().

                                                   {
     switch (literal.getTypeName()) {
     case DECIMAL:
       // Decimal and long have the same precision (as 64-bit integers), so
       // the unscaled value of a decimal must fit into a long.
 
       // REVIEW jvs 4-Aug-2004:  This should probably be calling over to
       // the available calculator implementations to see what they
       // support.  For now use ESP instead.
       //
       // jhyde 2006/12/21: I think the limits should be baked into the
       // type system, not dependent on the calculator implementation.
       BigDecimal bd = (BigDecimal) literal.getValue();
       BigInteger unscaled = bd.unscaledValue();
       long longValue = unscaled.longValue();
       if (!BigInteger.valueOf(longValue).equals(unscaled)) {
         // overflow
         throw newValidationError(literal,
             RESOURCE.numberLiteralOutOfRange(bd.toString()));
       }
       break;
 
     case DOUBLE:
       validateLiteralAsDouble(literal);
       break;
 
     case BINARY:
       final BitString bitString = (BitString) literal.getValue();
       if ((bitString.getBitCount() % 8) != 0) {
         throw newValidationError(literal, RESOURCE.binaryLiteralOdd());
       }
       break;
 
     case DATE:
     case TIME:
     case TIMESTAMP:
       Calendar calendar = literal.getValueAs(Calendar.class);
       final int year = calendar.get(Calendar.YEAR);
       final int era = calendar.get(Calendar.ERA);
       if (year < 1 || era == GregorianCalendar.BC || year > 9999) {
         throw newValidationError(literal,
             RESOURCE.dateLiteralOutOfRange(literal.toString()));
       }
       break;
 
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
     case INTERVAL_DAY:
     case INTERVAL_DAY_HOUR:
     case INTERVAL_DAY_MINUTE:
     case INTERVAL_DAY_SECOND:
     case INTERVAL_HOUR:
     case INTERVAL_HOUR_MINUTE:
     case INTERVAL_HOUR_SECOND:
     case INTERVAL_MINUTE:
     case INTERVAL_MINUTE_SECOND:
     case INTERVAL_SECOND:
       if (literal instanceof SqlIntervalLiteral) {
         SqlIntervalLiteral.IntervalValue interval =
             literal.getValueAs(SqlIntervalLiteral.IntervalValue.class);
         SqlIntervalQualifier intervalQualifier =
             interval.getIntervalQualifier();
 
         // ensure qualifier is good before attempting to validate literal
         validateIntervalQualifier(intervalQualifier);
         String intervalStr = interval.getIntervalLiteral();
         // throws CalciteContextException if string is invalid
         int[] values = intervalQualifier.evaluateIntervalLiteral(intervalStr,
             literal.getParserPosition(), typeFactory.getTypeSystem());
         Util.discard(values);
       }
       break;
     default:
       // default is to do nothing
     }
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateLiteralAsDouble ( SqlLiteral literal )

inlineprivate

Definition at line 3117 of file SqlValidatorImpl.java.

References Double, and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateLiteral().

                                                            {
     BigDecimal bd = (BigDecimal) literal.getValue();
     double d = bd.doubleValue();
     if (Double.isInfinite(d) || Double.isNaN(d)) {
       // overflow
       throw newValidationError(literal,
           RESOURCE.numberLiteralOutOfRange(Util.toScientificNotation(bd)));
     }
 
     // REVIEW jvs 4-Aug-2004:  what about underflow?
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateMatchRecognize ( SqlCall call )

inline

Definition at line 5133 of file SqlValidatorImpl.java.

                                                              {
     final SqlMatchRecognize matchRecognize = (SqlMatchRecognize) call;
     final MatchRecognizeScope scope =
         (MatchRecognizeScope) getMatchRecognizeScope(matchRecognize);
 
     final MatchRecognizeNamespace ns =
         getNamespace(call).unwrap(MatchRecognizeNamespace.class);
     assert ns.rowType == null;
 
     // rows per match
     final SqlLiteral rowsPerMatch = matchRecognize.getRowsPerMatch();
     final boolean allRows = rowsPerMatch != null
         && rowsPerMatch.getValue()
         == SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS;
 
     final RelDataTypeFactory.Builder typeBuilder = typeFactory.builder();
 
     // parse PARTITION BY column
     SqlNodeList partitionBy = matchRecognize.getPartitionList();
     if (partitionBy != null) {
       for (SqlNode node : partitionBy) {
         SqlIdentifier identifier = (SqlIdentifier) node;
         identifier.validate(this, scope);
         RelDataType type = deriveType(scope, identifier);
         String name = identifier.names.get(1);
         typeBuilder.add(name, type);
       }
     }
 
     // parse ORDER BY column
     SqlNodeList orderBy = matchRecognize.getOrderList();
     if (orderBy != null) {
       for (SqlNode node : orderBy) {
         node.validate(this, scope);
         SqlIdentifier identifier;
         if (node instanceof SqlBasicCall) {
           identifier = (SqlIdentifier) ((SqlBasicCall) node).getOperands()[0];
         } else {
           identifier = (SqlIdentifier) node;
         }
 
         if (allRows) {
           RelDataType type = deriveType(scope, identifier);
           String name = identifier.names.get(1);
           if (!typeBuilder.nameExists(name)) {
             typeBuilder.add(name, type);
           }
         }
       }
     }
 
     if (allRows) {
       final SqlValidatorNamespace sqlNs =
           getNamespace(matchRecognize.getTableRef());
       final RelDataType inputDataType = sqlNs.getRowType();
       for (RelDataTypeField fs : inputDataType.getFieldList()) {
         if (!typeBuilder.nameExists(fs.getName())) {
           typeBuilder.add(fs);
         }
       }
     }
 
     // retrieve pattern variables used in pattern and subset
     SqlNode pattern = matchRecognize.getPattern();
     PatternVarVisitor visitor = new PatternVarVisitor(scope);
     pattern.accept(visitor);
 
     SqlLiteral interval = matchRecognize.getInterval();
     if (interval != null) {
       interval.validate(this, scope);
       if (((SqlIntervalLiteral) interval).signum() < 0) {
         throw newValidationError(interval,
           RESOURCE.intervalMustBeNonNegative(interval.toValue()));
       }
       if (orderBy == null || orderBy.size() == 0) {
         throw newValidationError(interval,
           RESOURCE.cannotUseWithinWithoutOrderBy());
       }
 
       SqlNode firstOrderByColumn = orderBy.getList().get(0);
       SqlIdentifier identifier;
       if (firstOrderByColumn instanceof SqlBasicCall) {
         identifier = (SqlIdentifier) ((SqlBasicCall) firstOrderByColumn).getOperands()[0];
       } else {
         identifier = (SqlIdentifier) firstOrderByColumn;
       }
       RelDataType firstOrderByColumnType = deriveType(scope, identifier);
       if (firstOrderByColumnType.getSqlTypeName() != SqlTypeName.TIMESTAMP) {
         throw newValidationError(interval,
           RESOURCE.firstColumnOfOrderByMustBeTimestamp());
       }
 
       SqlNode expand = expand(interval, scope);
       RelDataType type = deriveType(scope, expand);
       setValidatedNodeType(interval, type);
     }
 
     validateDefinitions(matchRecognize, scope);
 
     SqlNodeList subsets = matchRecognize.getSubsetList();
     if (subsets != null && subsets.size() > 0) {
       for (SqlNode node : subsets) {
         List<SqlNode> operands = ((SqlCall) node).getOperandList();
         String leftString = ((SqlIdentifier) operands.get(0)).getSimple();
         if (scope.getPatternVars().contains(leftString)) {
           throw newValidationError(operands.get(0),
               RESOURCE.patternVarAlreadyDefined(leftString));
         }
         scope.addPatternVar(leftString);
         for (SqlNode right : (SqlNodeList) operands.get(1)) {
           SqlIdentifier id = (SqlIdentifier) right;
           if (!scope.getPatternVars().contains(id.getSimple())) {
             throw newValidationError(id,
                 RESOURCE.unknownPattern(id.getSimple()));
           }
           scope.addPatternVar(id.getSimple());
         }
       }
     }
 
     // validate AFTER ... SKIP TO
     final SqlNode skipTo = matchRecognize.getAfter();
     if (skipTo instanceof SqlCall) {
       final SqlCall skipToCall = (SqlCall) skipTo;
       final SqlIdentifier id = skipToCall.operand(0);
       if (!scope.getPatternVars().contains(id.getSimple())) {
         throw newValidationError(id,
             RESOURCE.unknownPattern(id.getSimple()));
       }
     }
 
     List<Map.Entry<String, RelDataType>> measureColumns =
         validateMeasure(matchRecognize, scope, allRows);
     for (Map.Entry<String, RelDataType> c : measureColumns) {
       if (!typeBuilder.nameExists(c.getKey())) {
         typeBuilder.add(c.getKey(), c.getValue());
       }
     }
 
     final RelDataType rowType = typeBuilder.build();
     if (matchRecognize.getMeasureList().size() == 0) {
       ns.setType(getNamespace(matchRecognize.getTableRef()).getRowType());
     } else {
       ns.setType(rowType);
     }
   }

Here is the call graph for this function:

List<Map.Entry<String, RelDataType> > org.apache.calcite.sql.validate.SqlValidatorImpl.validateMeasure	(	SqlMatchRecognize	mr,
		MatchRecognizeScope	scope,
		boolean	allRows
	)

inlineprivate

Definition at line 5280 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateMatchRecognize().

                                                   {
     final List<String> aliases = new ArrayList<>();
     final List<SqlNode> sqlNodes = new ArrayList<>();
     final SqlNodeList measures = mr.getMeasureList();
     final List<Map.Entry<String, RelDataType>> fields = new ArrayList<>();
 
     for (SqlNode measure : measures) {
       assert measure instanceof SqlCall;
       final String alias = deriveAlias(measure, aliases.size());
       aliases.add(alias);
 
       SqlNode expand = expand(measure, scope);
       expand = navigationInMeasure(expand, allRows);
       setOriginal(expand, measure);
 
       inferUnknownTypes(unknownType, scope, expand);
       final RelDataType type = deriveType(scope, expand);
       setValidatedNodeType(measure, type);
 
       fields.add(Pair.of(alias, type));
       sqlNodes.add(
           SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO, expand,
               new SqlIdentifier(alias, SqlParserPos.ZERO)));
     }
 
     SqlNodeList list = new SqlNodeList(sqlNodes, measures.getParserPosition());
     inferUnknownTypes(unknownType, scope, list);
 
     for (SqlNode node : list) {
       validateExpr(node, scope);
     }
 
     mr.setOperand(SqlMatchRecognize.OPERAND_MEASURES, list);
 
     return fields;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge ( SqlMerge call )

inline

Definition at line 4797 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.createTargetRowType(), org.apache.calcite.sql.validate.SqlValidatorImpl.getNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType, org.apache.calcite.sql.validate.SqlValidatorImpl.validateAccess(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateNamespace(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

                                            {
     SqlSelect sqlSelect = call.getSourceSelect();
     // REVIEW zfong 5/25/06 - Does an actual type have to be passed into
     // validateSelect()?
 
     // REVIEW jvs 6-June-2006:  In general, passing unknownType like
     // this means we won't be able to correctly infer the types
     // for dynamic parameter markers (SET x = ?).  But
     // maybe validateUpdate and validateInsert below will do
     // the job?
 
     // REVIEW ksecretan 15-July-2011: They didn't get a chance to
     // since validateSelect() would bail.
     // Let's use the update/insert targetRowType when available.
     IdentifierNamespace targetNamespace =
         (IdentifierNamespace) getNamespace(call.getTargetTable());
     validateNamespace(targetNamespace, unknownType);
 
     SqlValidatorTable table = targetNamespace.getTable();
     validateAccess(call.getTargetTable(), table, SqlAccessEnum.UPDATE);
 
     RelDataType targetRowType = unknownType;
 
     if (call.getUpdateCall() != null) {
       targetRowType = createTargetRowType(
           table,
           call.getUpdateCall().getTargetColumnList(),
           true);
     }
     if (call.getInsertCall() != null) {
       targetRowType = createTargetRowType(
           table,
           call.getInsertCall().getTargetColumnList(),
           false);
     }
 
     validateSelect(sqlSelect, targetRowType);
 
     if (call.getUpdateCall() != null) {
       validateUpdate(call.getUpdateCall());
     }
     if (call.getInsertCall() != null) {
       validateInsert(call.getInsertCall());
     }
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateModality ( SqlNode query )

inlineprivate

Validates that a query can deliver the modality it promises. Only called on the top-most SELECT or set operator in the tree.

Definition at line 3653 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.deduceModality(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery().

                                                {
     final SqlModality modality = deduceModality(query);
     if (query instanceof SqlSelect) {
       final SqlSelect select = (SqlSelect) query;
       validateModality(select, modality, true);
     } else if (query.getKind() == SqlKind.VALUES) {
       switch (modality) {
       case STREAM:
         throw newValidationError(query, Static.RESOURCE.cannotStreamValues());
       }
     } else {
       assert query.isA(SqlKind.SET_QUERY);
       final SqlCall call = (SqlCall) query;
       for (SqlNode operand : call.getOperandList()) {
         if (deduceModality(operand) != modality) {
           throw newValidationError(operand,
               Static.RESOURCE.streamSetOpInconsistentInputs());
         }
         validateModality(operand);
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.validateModality	(	SqlSelect	select,
		SqlModality	modality,
		boolean	fail
	)

inline

Definition at line 3692 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getAggregate(), org.apache.calcite.sql.validate.SqlValidatorImpl.getRawSelectScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.hasSortedPrefix(), setup.name, and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

                     {
     final SelectScope scope = getRawSelectScope(select);
 
     switch (modality) {
     case STREAM:
       if (scope.children.size() == 1) {
         for (ScopeChild child : scope.children) {
           if (!child.namespace.supportsModality(modality)) {
             if (fail) {
               throw newValidationError(child.namespace.getNode(),
                   Static.RESOURCE.cannotConvertToStream(child.name));
             } else {
               return false;
             }
           }
         }
       } else {
         int supportsModalityCount = 0;
         for (ScopeChild child : scope.children) {
           if (child.namespace.supportsModality(modality)) {
             ++supportsModalityCount;
           }
         }
 
         if (supportsModalityCount == 0) {
           if (fail) {
             String inputs = String.join(", ", scope.getChildNames());
             throw newValidationError(select,
                 Static.RESOURCE.cannotStreamResultsForNonStreamingInputs(inputs));
           } else {
             return false;
           }
         }
       }
       break;
     default:
       for (ScopeChild child : scope.children) {
         if (!child.namespace.supportsModality(modality)) {
           if (fail) {
             throw newValidationError(child.namespace.getNode(),
                 Static.RESOURCE.cannotConvertToRelation(child.name));
           } else {
             return false;
           }
         }
       }
     }
 
     // Make sure that aggregation is possible.
     final SqlNode aggregateNode = getAggregate(select);
     if (aggregateNode != null) {
       switch (modality) {
       case STREAM:
         SqlNodeList groupList = select.getGroup();
         if (groupList == null
             || !SqlValidatorUtil.containsMonotonic(scope, groupList)) {
           if (fail) {
             throw newValidationError(aggregateNode,
                 Static.RESOURCE.streamMustGroupByMonotonic());
           } else {
             return false;
           }
         }
       }
     }
 
     // Make sure that ORDER BY is possible.
     final SqlNodeList orderList  = select.getOrderList();
     if (orderList != null && orderList.size() > 0) {
       switch (modality) {
       case STREAM:
         if (!hasSortedPrefix(scope, orderList)) {
           if (fail) {
             throw newValidationError(orderList.get(0),
                 Static.RESOURCE.streamMustOrderByMonotonic());
           } else {
             return false;
           }
         }
       }
     }
     return true;
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateNamespace	(	final SqlValidatorNamespace	namespace,
		RelDataType	targetRowType
	)

inlineprotected

Validates a namespace.

Parameters

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

Definition at line 1095 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.setValidatedNodeType().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getLogicalTargetRowType(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateDelete(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWith().

                                  {
     namespace.validate(targetRowType);
     if (namespace.getNode() != null) {
       setValidatedNodeType(namespace.getNode(), namespace.getType());
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateNoAggs	(	AggFinder	aggFinder,
		SqlNode	node,
		String	clause
	)

inlineprivate

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

Parameters

aggFinder	Finder for the particular kind(s) of aggregate function
node	Parse tree
clause	Name of clause: "WHERE", "GROUP BY", "ON"

Definition at line 3353 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.SqlOperator.getName(), org.apache.calcite.sql.SqlOperator.isGroup(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereOrOn().

                                              {
     final SqlCall agg = aggFinder.findAgg(node);
     if (agg == null) {
       return;
     }
     final SqlOperator op = agg.getOperator();
     if (op == SqlStdOperatorTable.OVER) {
       throw newValidationError(agg,
           RESOURCE.windowedAggregateIllegalInClause(clause));
     } else if (op.isGroup() || op.isGroupAuxiliary()) {
       throw newValidationError(agg,
           RESOURCE.groupFunctionMustAppearInGroupByClause(op.getName()));
     } else {
       throw newValidationError(agg,
           RESOURCE.aggregateIllegalInClause(clause));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateNodeFeature ( SqlNode node )

inlineprivate

Definition at line 2958 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.validateFeature().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerSubQueries().

                                                  {
     switch (node.getKind()) {
     case MULTISET_VALUE_CONSTRUCTOR:
       validateFeature(RESOURCE.sQLFeature_S271(), node.getParserPosition());
       break;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderItem	(	SqlSelect	select,
		SqlNode	orderItem
	)

inlineprivate

Validates an item in the ORDER BY clause of a SELECT statement.

Parameters

select	Select statement
orderItem	ORDER BY clause item

Definition at line 3995 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getOrderScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateExpr(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateFeature().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderList().

                                                                       {
     switch (orderItem.getKind()) {
     case DESCENDING:
       validateFeature(RESOURCE.sQLConformance_OrderByDesc(),
           orderItem.getParserPosition());
       validateOrderItem(select,
           ((SqlCall) orderItem).operand(0));
       return;
     }
 
     final SqlValidatorScope orderScope = getOrderScope(select);
     validateExpr(orderItem, orderScope);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderList ( SqlSelect select )

inlineprotected

Validates the ORDER BY clause of a SELECT statement.

Parameters

select Select statement

Definition at line 3929 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.cursorSet, org.apache.calcite.sql.validate.SqlValidatorImpl.expand(), org.apache.calcite.sql.validate.SqlValidatorImpl.getOrderScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), org.apache.calcite.sql.validate.SqlValidatorImpl.shouldAllowIntermediateOrderBy(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderItem().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                      {
     // ORDER BY is validated in a scope where aliases in the SELECT clause
     // are visible. For example, "SELECT empno AS x FROM emp ORDER BY x"
     // is valid.
     SqlNodeList orderList = select.getOrderList();
     if (orderList == null) {
       return;
     }
     if (!shouldAllowIntermediateOrderBy()) {
       if (!cursorSet.contains(select)) {
         throw newValidationError(select, RESOURCE.invalidOrderByPos());
       }
     }
     final SqlValidatorScope orderScope = getOrderScope(select);
     Objects.requireNonNull(orderScope);
 
     List<SqlNode> expandList = new ArrayList<>();
     for (SqlNode orderItem : orderList) {
       SqlNode expandedOrderItem = expand(orderItem, orderScope);
       expandList.add(expandedOrderItem);
     }
 
     SqlNodeList expandedOrderList = new SqlNodeList(
         expandList,
         orderList.getParserPosition());
     select.setOrderBy(expandedOrderList);
 
     for (SqlNode orderItem : expandedOrderList) {
       validateOrderItem(select, orderItem);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateOver	(	SqlCall	call,
		SqlValidatorScope	scope
	)

inlineprotected

Definition at line 3207 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateFrom().

                                                                      {
     throw new AssertionError("OVER unexpected in this context");
   }

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.validateParameterizedExpression	(	SqlNode	topNode,
		final Map< String, RelDataType >	nameToTypeMap
	)

inline

Definition at line 1029 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.validateScopedExpression().

                                                     {
     SqlValidatorScope scope = new ParameterScope(this, nameToTypeMap);
     return validateScopedExpression(topNode, scope);
   }

Here is the call graph for this function:

static void org.apache.calcite.sql.validate.SqlValidatorImpl.validateQualifiedCommonColumn	(	SqlJoin	join,
		SqlIdentifier	identifier,
		SelectScope	scope,
		SqlValidatorImpl	validator
	)

inlinestaticprivate

Definition at line 565 of file SqlValidatorImpl.java.

References join().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandCommonColumn().

                                                                                {
     List<String> names = validator.usingNames(join);
     if (names == null) {
       // Not USING or NATURAL.
       return;
     }
 
     // First we should make sure that the first component is the table name.
     // Then check whether the qualified identifier contains common column.
     for (ScopeChild child : scope.children) {
       if (child.name.equals(identifier.getComponent(0).toString())) {
         if (names.indexOf(identifier.getComponent(1).toString()) >= 0) {
           throw validator.newValidationError(identifier,
               RESOURCE.disallowsQualifyingCommonColumn(identifier.toString()));
         }
       }
     }
 
     // Only need to try to validate the expr from the left input of join
     // since it is always left-deep join.
     final SqlNode node = join.getLeft();
     if (node instanceof SqlJoin) {
       validateQualifiedCommonColumn((SqlJoin) node, identifier, scope, validator);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery	(	SqlNode	node,
		SqlValidatorScope	scope,
		RelDataType	targetRowType
	)

inline

Definition at line 1056 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateFrom(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUnnest().

                                  {
     final SqlValidatorNamespace ns = getNamespace(node, scope);
     if (node.getKind() == SqlKind.TABLESAMPLE) {
       List<SqlNode> operands = ((SqlCall) node).getOperandList();
       SqlSampleSpec sampleSpec = SqlLiteral.sampleValue(operands.get(1));
       if (sampleSpec instanceof SqlSampleSpec.SqlTableSampleSpec) {
         validateFeature(RESOURCE.sQLFeature_T613(), node.getParserPosition());
       } else if (sampleSpec
           instanceof SqlSampleSpec.SqlSubstitutionSampleSpec) {
         validateFeature(RESOURCE.sQLFeatureExt_T613_Substitution(),
             node.getParserPosition());
       }
     }
 
     validateNamespace(ns, targetRowType);
     switch (node.getKind()) {
     case EXTEND:
       // Until we have a dedicated namespace for EXTEND
       deriveType(scope, node);
     }
     if (node == top) {
       validateModality(node);
     }
     validateAccess(
         node,
         ns.getTable(),
         SqlAccessEnum.SELECT);
 
     validateSnapshot(node, scope, ns);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.validateScopedExpression	(	SqlNode	topNode,
		SqlValidatorScope	scope
	)

inlineprivate

Definition at line 1036 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.top.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validate(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateParameterizedExpression().

                                {
     SqlNode outermostNode = performUnconditionalRewrites(topNode, false);
     cursorSet.add(outermostNode);
     top = outermostNode;
     TRACER.trace("After unconditional rewrite: {}", outermostNode);
     if (outermostNode.isA(SqlKind.TOP_LEVEL)) {
       registerQuery(scope, null, outermostNode, outermostNode, null, false);
     }
     outermostNode.validate(this, scope);
     if (!outermostNode.isA(SqlKind.TOP_LEVEL)) {
       // force type derivation so that we can provide it to the
       // caller later without needing the scope
       deriveType(scope, outermostNode);
     }
     TRACER.trace("After validation: {}", outermostNode);
     return outermostNode;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect	(	SqlSelect	select,
		RelDataType	targetRowType
	)

inlineprotected

Validates a SELECT statement.

Parameters

select	Select statement
targetRowType	Desired row type, must not be null, may be the data type 'unknown'.

Definition at line 3397 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateDelete(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

                                  {
     assert targetRowType != null;
     // Namespace is either a select namespace or a wrapper around one.
     final SelectNamespace ns =
         getNamespace(select).unwrap(SelectNamespace.class);
 
     // Its rowtype is null, meaning it hasn't been validated yet.
     // This is important, because we need to take the targetRowType into
     // account.
     assert ns.rowType == null;
 
     if (select.isDistinct()) {
       validateFeature(RESOURCE.sQLFeature_E051_01(),
           select.getModifierNode(SqlSelectKeyword.DISTINCT)
               .getParserPosition());
     }
 
     final SqlNodeList selectItems = select.getSelectList();
     RelDataType fromType = unknownType;
     if (selectItems.size() == 1) {
       final SqlNode selectItem = selectItems.get(0);
       if (selectItem instanceof SqlIdentifier) {
         SqlIdentifier id = (SqlIdentifier) selectItem;
         if (id.isStar() && (id.names.size() == 1)) {
           // Special case: for INSERT ... VALUES(?,?), the SQL
           // standard says we're supposed to propagate the target
           // types down.  So iff the select list is an unqualified
           // star (as it will be after an INSERT ... VALUES has been
           // expanded), then propagate.
           fromType = targetRowType;
         }
       }
     }
 
     // Make sure that items in FROM clause have distinct aliases.
     final SelectScope fromScope = (SelectScope) getFromScope(select);
     List<String> names = fromScope.getChildNames();
     if (!catalogReader.nameMatcher().isCaseSensitive()) {
       names = names.stream()
           .map(s -> s.toUpperCase(Locale.ROOT))
           .collect(Collectors.toList());
     }
     final int duplicateAliasOrdinal = Util.firstDuplicate(names);
     if (duplicateAliasOrdinal >= 0) {
       final ScopeChild child =
           fromScope.children.get(duplicateAliasOrdinal);
       throw newValidationError(child.namespace.getEnclosingNode(),
           RESOURCE.fromAliasDuplicate(child.name));
     }
 
     if (select.getFrom() == null) {
       if (this.config.sqlConformance().isFromRequired()) {
         throw newValidationError(select, RESOURCE.selectMissingFrom());
       }
     } else {
       validateFrom(select.getFrom(), fromType, fromScope);
     }
 
     validateWhereClause(select);
     validateGroupClause(select);
     validateHavingClause(select);
     validateWindowClause(select);
     handleOffsetFetch(select.getOffset(), select.getFetch());
 
     // Validate the SELECT clause late, because a select item might
     // depend on the GROUP BY list, or the window function might reference
     // window name in the WINDOW clause etc.
     final RelDataType rowType =
         validateSelectList(selectItems, select, targetRowType);
     ns.setType(rowType);
 
     // Validate ORDER BY after we have set ns.rowType because in some
     // dialects you can refer to columns of the select list, e.g.
     // "SELECT empno AS x FROM emp ORDER BY x"
     validateOrderList(select);
 
     if (shouldCheckForRollUp(select.getFrom())) {
       checkRollUpInSelectList(select);
       checkRollUp(null, select, select.getWhere(), getWhereScope(select));
       checkRollUp(null, select, select.getHaving(), getHavingScope(select));
       checkRollUpInWindowDecl(select);
       checkRollUpInGroupBy(select);
       checkRollUpInOrderBy(select);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList	(	final SqlNodeList	selectItems,
		SqlSelect	select,
		RelDataType	targetRowType
	)

inlineprotected

Definition at line 4168 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                  {
     // First pass, ensure that aliases are unique. "*" and "TABLE.*" items
     // are ignored.
 
     // Validate SELECT list. Expand terms of the form "*" or "TABLE.*".
     final SqlValidatorScope selectScope = getSelectScope(select);
     final List<SqlNode> expandedSelectItems = new ArrayList<>();
     final Set<String> aliases = new HashSet<>();
     final List<Map.Entry<String, RelDataType>> fieldList = new ArrayList<>();
 
     for (SqlNode selectItem : selectItems) {
       if (selectItem instanceof SqlSelect) {
         handleScalarSubQuery(
             select,
             (SqlSelect) selectItem,
             expandedSelectItems,
             aliases,
             fieldList);
       } else {
         // Use the field list size to record the field index
         // because the select item may be a STAR(*), which could have been expanded.
         final int fieldIdx = fieldList.size();
         final RelDataType fieldType =
                 targetRowType.isStruct()
                         && targetRowType.getFieldCount() > fieldIdx
                 ? targetRowType.getFieldList().get(fieldIdx).getType()
                 : unknownType;
         expandSelectItem(
             selectItem,
             select,
             fieldType,
             expandedSelectItems,
             aliases,
             fieldList,
             false);
       }
     }
 
     // Create the new select list with expanded items.  Pass through
     // the original parser position so that any overall failures can
     // still reference the original input text.
     SqlNodeList newSelectList =
         new SqlNodeList(
             expandedSelectItems,
             selectItems.getParserPosition());
     if (config.identifierExpansion()) {
       select.setSelectList(newSelectList);
     }
     getRawSelectScope(select).setExpandedSelectList(expandedSelectItems);
 
     // TODO: when SELECT appears as a value sub-query, should be using
     // something other than unknownType for targetRowType
     inferUnknownTypes(targetRowType, selectScope, newSelectList);
 
     for (SqlNode selectItem : expandedSelectItems) {
       validateNoAggs(groupFinder, selectItem, "SELECT");
       validateExpr(selectItem, selectScope);
     }
 
     return typeFactory.createStructType(fieldList);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateSequenceValue	(	SqlValidatorScope	scope,
		SqlIdentifier	id
	)

inline

Definition at line 3883 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

                                                                                {
     // Resolve identifier as a table.
     final SqlValidatorScope.ResolvedImpl resolved =
         new SqlValidatorScope.ResolvedImpl();
     scope.resolveTable(id.names, catalogReader.nameMatcher(),
         SqlValidatorScope.Path.EMPTY, resolved);
     if (resolved.count() != 1) {
       throw newValidationError(id, RESOURCE.tableNameNotFound(id.toString()));
     }
     // We've found a table. But is it a sequence?
     final SqlValidatorNamespace ns = resolved.only().namespace;
     if (ns instanceof TableNamespace) {
       final Table table = ns.getTable().unwrap(Table.class);
       switch (table.getJdbcTableType()) {
       case SEQUENCE:
       case TEMPORARY_SEQUENCE:
         return;
       }
     }
     throw newValidationError(id, RESOURCE.notASequence(id.toString()));
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateSnapshot	(	SqlNode	node,
		SqlValidatorScope	scope,
		SqlValidatorNamespace	ns
	)

inlineprivate

Validates snapshot to a table.

Parameters

node	The node to validate
scope	Validator scope to derive type
ns	The namespace to lookup table

Definition at line 4870 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery().

                                 {
     if (node.getKind() == SqlKind.SNAPSHOT) {
       SqlSnapshot snapshot = (SqlSnapshot) node;
       SqlNode period = snapshot.getPeriod();
       RelDataType dataType = deriveType(scope, period);
       if (dataType.getSqlTypeName() != SqlTypeName.TIMESTAMP) {
         throw newValidationError(period,
             Static.RESOURCE.illegalExpressionForTemporal(dataType.getSqlTypeName().getName()));
       }
       if (!ns.getTable().isTemporal()) {
         List<String> qualifiedName = ns.getTable().getQualifiedName();
         String tableName = qualifiedName.get(qualifiedName.size() - 1);
         throw newValidationError(snapshot.getTableRef(),
             Static.RESOURCE.notTemporalTable(tableName));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateUnnest	(	SqlCall	call,
		SqlValidatorScope	scope,
		RelDataType	targetRowType
	)

inlineprotected

Definition at line 3211 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.expand(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateFrom().

                                                                                                   {
     for (int i = 0; i < call.operandCount(); i++) {
       SqlNode expandedItem = expand(call.operand(i), scope);
       call.setOperand(i, expandedItem);
     }
     validateQuery(call, scope, targetRowType);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate ( SqlUpdate call )

inline

Definition at line 4767 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateMerge().

                                              {
     final SqlValidatorNamespace targetNamespace = getNamespace(call);
     validateNamespace(targetNamespace, unknownType);
     final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
         targetNamespace, catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
     final SqlValidatorTable table = relOptTable == null
         ? targetNamespace.getTable()
         : relOptTable.unwrap(SqlValidatorTable.class);
 
     final RelDataType targetRowType =
         createTargetRowType(
             table,
             call.getTargetColumnList(),
             true);
 
     final SqlSelect select = call.getSourceSelect();
     validateSelect(select, targetRowType);
 
     final RelDataType sourceRowType = getValidatedNodeType(select);
     checkTypeAssignment(scopes.get(select),
         table,
         sourceRowType,
         targetRowType,
         call);
 
     checkConstraint(table, call, targetRowType);
 
     validateAccess(call.getTargetTable(), table, SqlAccessEnum.UPDATE);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.validateUsingCol	(	SqlIdentifier	id,
		SqlNode	leftOrRight
	)

inlineprivate

Definition at line 3372 of file SqlValidatorImpl.java.

References field(), setup.name, and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin().

                                                                               {
     if (id.names.size() == 1) {
       String name = id.names.get(0);
       final SqlValidatorNamespace namespace = getNamespace(leftOrRight);
       final RelDataType rowType = namespace.getRowType();
       final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
       final RelDataTypeField field = nameMatcher.field(rowType, name);
       if (field != null) {
         if (nameMatcher.frequency(rowType.getFieldNames(), name) > 1) {
           throw newValidationError(id,
               RESOURCE.columnInUsingNotUnique(id.toString()));
         }
         return field.getType();
       }
     }
     throw newValidationError(id, RESOURCE.columnNotFound(id.toString()));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateValues	(	SqlCall	node,
		RelDataType	targetRowType,
		final SqlValidatorScope	scope
	)

inlineprotected

Validates a VALUES clause.

Parameters

node	Values clause
targetRowType	Row type which expression must conform to
scope	Scope within which clause occurs

Definition at line 4898 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.config(), org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.inferUnknownTypes(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and run_benchmark_import.type.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateFrom().

                                      {
     assert node.getKind() == SqlKind.VALUES;
 
     final List<SqlNode> operands = node.getOperandList();
     for (SqlNode operand : operands) {
       if (!(operand.getKind() == SqlKind.ROW)) {
         throw Util.needToImplement(
             "Values function where operands are scalars");
       }
 
       SqlCall rowConstructor = (SqlCall) operand;
       if (this.config.sqlConformance().isInsertSubsetColumnsAllowed()
           && targetRowType.isStruct()
           && rowConstructor.operandCount() < targetRowType.getFieldCount()) {
         targetRowType =
             typeFactory.createStructType(
                 targetRowType.getFieldList()
                     .subList(0, rowConstructor.operandCount()));
       } else if (targetRowType.isStruct()
           && rowConstructor.operandCount() != targetRowType.getFieldCount()) {
         return;
       }
 
       inferUnknownTypes(
           targetRowType,
           scope,
           rowConstructor);
 
       if (targetRowType.isStruct()) {
         for (Pair<SqlNode, RelDataTypeField> pair
             : Pair.zip(rowConstructor.getOperandList(),
                 targetRowType.getFieldList())) {
           if (!pair.right.getType().isNullable()
               && SqlUtil.isNullLiteral(pair.left, false)) {
             throw newValidationError(node,
                 RESOURCE.columnNotNullable(pair.right.getName()));
           }
         }
       }
     }
 
     for (SqlNode operand : operands) {
       operand.validate(this, scope);
     }
 
     // validate that all row types have the same number of columns
     //  and that expressions in each column are compatible.
     // A values expression is turned into something that looks like
     // ROW(type00, type01,...), ROW(type11,...),...
     final int rowCount = operands.size();
     if (rowCount >= 2) {
       SqlCall firstRow = (SqlCall) operands.get(0);
       final int columnCount = firstRow.operandCount();
 
       // 1. check that all rows have the same cols length
       for (SqlNode operand : operands) {
         SqlCall thisRow = (SqlCall) operand;
         if (columnCount != thisRow.operandCount()) {
           throw newValidationError(node,
               RESOURCE.incompatibleValueType(
                   SqlStdOperatorTable.VALUES.getName()));
         }
       }
 
       // 2. check if types at i:th position in each row are compatible
       for (int col = 0; col < columnCount; col++) {
         final int c = col;
         final RelDataType type =
             typeFactory.leastRestrictive(
                 new AbstractList<RelDataType>() {
                   public RelDataType get(int row) {
                     SqlCall thisRow = (SqlCall) operands.get(row);
                     return deriveType(scope, thisRow.operand(c));
                   }
 
                   public int size() {
                     return rowCount;
                   }
                 });
 
         if (null == type) {
           throw newValidationError(node,
               RESOURCE.incompatibleValueType(
                   SqlStdOperatorTable.VALUES.getName()));
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereClause ( SqlSelect select )

inlineprotected

Definition at line 4109 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.expand(), org.apache.calcite.sql.validate.SqlValidatorImpl.getWhereScope(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereOrOn().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                        {
     // validate WHERE clause
     final SqlNode where = select.getWhere();
     if (where == null) {
       return;
     }
     final SqlValidatorScope whereScope = getWhereScope(select);
     final SqlNode expandedWhere = expand(where, whereScope);
     select.setWhere(expandedWhere);
     validateWhereOrOn(whereScope, expandedWhere, "WHERE");
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereOrOn	(	SqlValidatorScope	scope,
		SqlNode	condition,
		String	clause
	)

inlineprotected

Definition at line 4121 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.aggOrOverOrGroupFinder, org.apache.calcite.sql.validate.SqlValidatorImpl.booleanType, org.apache.calcite.sql.validate.SqlValidatorImpl.deriveType(), org.apache.calcite.sql.validate.SqlValidatorImpl.inferUnknownTypes(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), run_benchmark_import.type, and org.apache.calcite.sql.validate.SqlValidatorImpl.validateNoAggs().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateJoin(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereClause().

                      {
     validateNoAggs(aggOrOverOrGroupFinder, condition, clause);
     inferUnknownTypes(
         booleanType,
         scope,
         condition);
     condition.validate(this, scope);
 
     final RelDataType type = deriveType(scope, condition);
     if (!SqlTypeUtil.inBooleanFamily(type)) {
       throw newValidationError(condition, RESOURCE.condMustBeBoolean(clause));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateWindow	(	SqlNode	windowOrId,
		SqlValidatorScope	scope,
		SqlCall	call
	)

inline

Definition at line 5100 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getWindowByName(), org.apache.calcite.sql.validate.SqlValidatorImpl.inWindow, and org.apache.calcite.sql.validate.SqlValidatorImpl.validateAggregateParams().

                     {
     // Enable nested aggregates with window aggregates (OVER operator)
     inWindow = true;
 
     final SqlWindow targetWindow;
     switch (windowOrId.getKind()) {
     case IDENTIFIER:
       // Just verify the window exists in this query.  It will validate
       // when the definition is processed
       targetWindow = getWindowByName((SqlIdentifier) windowOrId, scope);
       break;
     case WINDOW:
       targetWindow = (SqlWindow) windowOrId;
       break;
     default:
       throw Util.unexpected(windowOrId.getKind());
     }
 
     assert targetWindow.getWindowCall() == null;
     targetWindow.setWindowCall(call);
     targetWindow.validate(this, scope);
     targetWindow.setWindowCall(null);
     call.validate(this, scope);
 
     validateAggregateParams(call, null, null, scope);
 
     // Disable nested aggregates post validation
     inWindow = false;
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateWindowClause ( SqlSelect select )

inlineprotected

Definition at line 3802 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.expand(), org.apache.calcite.sql.validate.SqlValidatorImpl.getFromScope(), and org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError().

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

                                                         {
     final SqlNodeList windowList = select.getWindowList();
     @SuppressWarnings("unchecked") final List<SqlWindow> windows =
         (List) windowList.getList();
     if (windows.isEmpty()) {
       return;
     }
 
     final SelectScope windowScope = (SelectScope) getFromScope(select);
     assert windowScope != null;
 
     // 1. ensure window names are simple
     // 2. ensure they are unique within this scope
     for (SqlWindow window : windows) {
       SqlIdentifier declName = window.getDeclName();
       if (!declName.isSimple()) {
         throw newValidationError(declName, RESOURCE.windowNameMustBeSimple());
       }
 
       if (windowScope.existingWindowName(declName.toString())) {
         throw newValidationError(declName, RESOURCE.duplicateWindowName());
       } else {
         windowScope.addWindowName(declName.toString());
       }
     }
 
     // 7.10 rule 2
     // Check for pairs of windows which are equivalent.
     for (int i = 0; i < windows.size(); i++) {
       SqlNode window1 = windows.get(i);
       for (int j = i + 1; j < windows.size(); j++) {
         SqlNode window2 = windows.get(j);
         if (window1.equalsDeep(window2, Litmus.IGNORE)) {
           throw newValidationError(window2, RESOURCE.dupWindowSpec());
         }
       }
     }
 
     for (SqlWindow window : windows) {
       final SqlNodeList expandedOrderList =
           (SqlNodeList) expand(window.getOrderList(), windowScope);
       window.setOrderList(expandedOrderList);
       expandedOrderList.validate(this, windowScope);
 
       final SqlNodeList expandedPartitionList =
           (SqlNodeList) expand(window.getPartitionList(), windowScope);
       window.setPartitionList(expandedPartitionList);
       expandedPartitionList.validate(this, windowScope);
     }
 
     // Hand off to validate window spec components
     windowList.validate(this, windowScope);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateWith	(	SqlWith	with,
		SqlValidatorScope	scope
	)

inline

Definition at line 3856 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType, and org.apache.calcite.sql.validate.SqlValidatorImpl.validateNamespace().

                                                                   {
     final SqlValidatorNamespace namespace = getNamespace(with);
     validateNamespace(namespace, unknownType);
   }

Here is the call graph for this function:

void org.apache.calcite.sql.validate.SqlValidatorImpl.validateWithItem ( SqlWithItem withItem )

inline

Definition at line 3861 of file SqlValidatorImpl.java.

References org.apache.calcite.sql.validate.SqlValidatorImpl.getValidatedNodeType(), org.apache.calcite.sql.validate.SqlValidatorImpl.newValidationError(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validationErrorFunction.

                                                      {
     if (withItem.columnList != null) {
       final RelDataType rowType = getValidatedNodeType(withItem.query);
       final int fieldCount = rowType.getFieldCount();
       if (withItem.columnList.size() != fieldCount) {
         throw newValidationError(withItem.columnList,
             RESOURCE.columnCountMismatch());
       }
       SqlValidatorUtil.checkIdentifierListForDuplicates(
           withItem.columnList.getList(), validationErrorFunction);
     } else {
       // Luckily, field names have not been make unique yet.
       final List<String> fieldNames =
           getValidatedNodeType(withItem.query).getFieldNames();
       final int i = Util.firstDuplicate(fieldNames);
       if (i >= 0) {
         throw newValidationError(withItem.query,
             RESOURCE.duplicateColumnAndNoColumnList(fieldNames.get(i)));
       }
     }
   }

Here is the call graph for this function:

Member Data Documentation

final AggFinder org.apache.calcite.sql.validate.SqlValidatorImpl.aggFinder

private

Definition at line 265 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isNestedAggregateWindow(), and org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl().

final AggFinder org.apache.calcite.sql.validate.SqlValidatorImpl.aggOrOverFinder

private

Definition at line 266 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateAggregateParams(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateGroupClause().

final AggFinder org.apache.calcite.sql.validate.SqlValidatorImpl.aggOrOverOrGroupFinder

private

Definition at line 267 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereOrOn().

final RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.booleanType

private

Definition at line 256 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.inferUnknownTypes(), org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateDefinitions(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateHavingClause(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWhereOrOn().

final SqlValidatorCatalogReader org.apache.calcite.sql.validate.SqlValidatorImpl.catalogReader

package

Definition at line 202 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.createTargetRowType(), org.apache.calcite.sql.validate.SqlValidatorImpl.getCatalogReader(), org.apache.calcite.sql.validate.SqlValidatorImpl.handleUnresolvedFunction(), org.apache.calcite.sql.validate.SqlValidatorImpl.isNestedAggregateWindow(), org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelect().

final Map<IdPair<SqlSelect, Clause>, SqlValidatorScope> org.apache.calcite.sql.validate.SqlValidatorImpl.clauseScopes = new HashMap<>()

private

Maps a SqlSelect and a clause to the scope used by that clause.

Definition at line 221 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

Config org.apache.calcite.sql.validate.SqlValidatorImpl.config

private

Definition at line 271 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.expandCommonColumn(), and org.apache.calcite.sql.validate.SqlValidatorImpl.ExtendedExpander.visit().

final Set<SqlNode> org.apache.calcite.sql.validate.SqlValidatorImpl.cursorSet = Sets.newIdentityHashSet()

private

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

Definition at line 241 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateOrderList().

final Deque<FunctionParamInfo> org.apache.calcite.sql.validate.SqlValidatorImpl.functionCallStack

protected

Initial value:

=

new ArrayDeque<>()

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.

Definition at line 248 of file SqlValidatorImpl.java.

final AggFinder org.apache.calcite.sql.validate.SqlValidatorImpl.groupFinder

private

Definition at line 268 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateSelectList().

final Map<String, IdInfo> org.apache.calcite.sql.validate.SqlValidatorImpl.idPositions = new HashMap<>()

protected

Maps SqlParserPos strings to the SqlIdentifier identifier objects at these positions.

Definition at line 208 of file SqlValidatorImpl.java.

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.inWindow

private

Definition at line 281 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateAggregateParams(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWindow().

final Map<SqlNode, SqlValidatorNamespace> org.apache.calcite.sql.validate.SqlValidatorImpl.namespaces

protected

Initial value:

=

new IdentityHashMap<>()

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

Definition at line 233 of file SqlValidatorImpl.java.

int org.apache.calcite.sql.validate.SqlValidatorImpl.nextGeneratedId

private

Definition at line 251 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.declareCursor(), org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom(), and org.apache.calcite.sql.validate.SqlValidatorImpl.registerQuery().

final Map<SqlNode, RelDataType> org.apache.calcite.sql.validate.SqlValidatorImpl.nodeToTypeMap

private

Initial value:

=

new IdentityHashMap<>()

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.

Definition at line 263 of file SqlValidatorImpl.java.

final SqlOperatorTable org.apache.calcite.sql.validate.SqlValidatorImpl.opTab

private

Definition at line 201 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getOperatorTable(), org.apache.calcite.sql.validate.SqlValidatorImpl.isNestedAggregateWindow(), and org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl().

final Map<SqlNode, SqlNode> org.apache.calcite.sql.validate.SqlValidatorImpl.originalExprs = new HashMap<>()

private

Definition at line 273 of file SqlValidatorImpl.java.

final AggFinder org.apache.calcite.sql.validate.SqlValidatorImpl.overFinder

private

Definition at line 269 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.isAggregate(), org.apache.calcite.sql.validate.SqlValidatorImpl.SqlValidatorImpl(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateAggregateParams().

final Map<SqlNode, SqlValidatorScope> org.apache.calcite.sql.validate.SqlValidatorImpl.scopes

protected

Initial value:

=

new IdentityHashMap<>()

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

Definition at line 214 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getWithScope(), org.apache.calcite.sql.validate.SqlValidatorImpl.validateInsert(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateUpdate().

TableScope org.apache.calcite.sql.validate.SqlValidatorImpl.tableScope = null

private

The name-resolution scope of a LATERAL TABLE clause.

Definition at line 226 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.registerFrom().

SqlNode org.apache.calcite.sql.validate.SqlValidatorImpl.top

private

Definition at line 275 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateQuery(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateScopedExpression().

final Logger org.apache.calcite.sql.validate.SqlValidatorImpl.TRACER = CalciteTrace.PARSER_LOGGER

static

Definition at line 181 of file SqlValidatorImpl.java.

TypeCoercion org.apache.calcite.sql.validate.SqlValidatorImpl.typeCoercion

private

Definition at line 287 of file SqlValidatorImpl.java.

final RelDataTypeFactory org.apache.calcite.sql.validate.SqlValidatorImpl.typeFactory

protected

Definition at line 252 of file SqlValidatorImpl.java.

final RelDataType org.apache.calcite.sql.validate.SqlValidatorImpl.unknownType

protected

The type of dynamic parameters until a type is imposed on them.

Definition at line 255 of file SqlValidatorImpl.java.

final String org.apache.calcite.sql.validate.SqlValidatorImpl.UPDATE_ANON_PREFIX = "SYS$ANON"

static

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

Definition at line 197 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteUpdateToMerge().

final String org.apache.calcite.sql.validate.SqlValidatorImpl.UPDATE_SRC_ALIAS = "SYS$SRC"

static

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

Definition at line 186 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites(), and org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteUpdateToMerge().

final String org.apache.calcite.sql.validate.SqlValidatorImpl.UPDATE_TGT_ALIAS = "SYS$TGT"

static

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

Definition at line 192 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.rewriteUpdateToMerge().

boolean org.apache.calcite.sql.validate.SqlValidatorImpl.validatingSqlMerge

private

Definition at line 279 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.performUnconditionalRewrites().

final SqlValidatorImpl.ValidationErrorFunction org.apache.calcite.sql.validate.SqlValidatorImpl.validationErrorFunction

private

Initial value:

=

new SqlValidatorImpl.ValidationErrorFunction()

Definition at line 283 of file SqlValidatorImpl.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.getValidationErrorFunction(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateWithItem().

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/java/calcite/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java

Classes

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Package Functions

Package Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation