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 176 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 297 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);
     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 719 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 1981 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 5378 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 4428 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 4482 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 4532 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 3532 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 3557 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 3489 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 3498 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 3482 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 3216 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 3507 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 3519 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 4642 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 3912 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 2034 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 2460 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 2475 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 1634 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 1605 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 4313 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 370 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 3674 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 1999 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 1787 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 1753 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 1779 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 5521 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 540 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 473 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 5530 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 4006 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 5511 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 421 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 347 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 589 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 984 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 968 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 3583 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 2939 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 2925 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 331 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 327 of file SqlValidatorImpl.java.

                                          {
     return config.sqlConformance();
   }

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

inline

Definition at line 1105 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 1101 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 5561 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 5545 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 1135 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 1130 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 1125 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 1431 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 1147 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 4622 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 4598 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 1143 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 1155 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 1187 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 1200 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 4720 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 335 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 1139 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 5075 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 1151 of file SqlValidatorImpl.java.

                                                       {
     return scopes.get(node);
   }

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

inline

Definition at line 5594 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 402 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 1117 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 1113 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 1592 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 1652 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(), 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 3907 of file SqlValidatorImpl.java.

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

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

inline

Definition at line 339 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 343 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 1682 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 1691 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 5025 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 1109 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 5036 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 3562 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 3902 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 1222 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 4267 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 1840 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 3775 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 1869 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 2891 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 2951 of file SqlValidatorImpl.java.

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

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

inlinestaticprivate

Definition at line 5640 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 5636 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 2908 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 2915 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 5632 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 3622 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 3600 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 4588 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 5646 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 5650 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 3779 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 5541 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 4575 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 5088 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 825 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 757 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 865 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 902 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 779 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 800 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 815 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 1734 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 711 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 5388 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 5315 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 5029 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 1242 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 397 of file SqlValidatorImpl.java.

                                 {
     functionCallStack.pop();
   }

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

inline

Definition at line 391 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 2093 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 2009 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 2051 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 3006 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 2491 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 2521 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());
     }
   }

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