You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by dw...@apache.org on 2018/12/17 08:25:20 UTC
[flink] 05/06: [FLINK-7599][table] Throw exception on DISTINCT in
aggregations in MATCH_RECOGNIZE
This is an automated email from the ASF dual-hosted git repository.
dwysakowicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git
commit 41b3a3bb6fdbd2c22a3cc76317ada2f7c5bb98f3
Author: Dawid Wysakowicz <dw...@apache.org>
AuthorDate: Thu Nov 29 10:41:49 2018 +0100
[FLINK-7599][table] Throw exception on DISTINCT in aggregations in MATCH_RECOGNIZE
---
docs/dev/table/streaming/match_recognize.md | 2 +-
.../calcite/sql/validate/SqlValidatorImpl.java | 6340 ++++++++++++++++++++
.../table/match/MatchRecognizeValidationTest.scala | 21 +
.../runtime/stream/sql/MatchRecognizeITCase.scala | 2 +-
4 files changed, 6363 insertions(+), 2 deletions(-)
diff --git a/docs/dev/table/streaming/match_recognize.md b/docs/dev/table/streaming/match_recognize.md
index 7c9ade4..fc16596 100644
--- a/docs/dev/table/streaming/match_recognize.md
+++ b/docs/dev/table/streaming/match_recognize.md
@@ -959,4 +959,4 @@ Unsupported features include:
* Extracting time attributes - there is currently no possibility to get a time attribute for subsequent time-based operations.
* `MATCH_RECOGNIZE` is supported only for SQL. There is no equivalent in the Table API.
* Aggregations:
- * distinct aggregations are not supported. Moreover if specified it will be silently dropped unfortunately.
+ * distinct aggregations are not supported.
diff --git a/flink-libraries/flink-table/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/flink-libraries/flink-table/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
new file mode 100644
index 0000000..f318166
--- /dev/null
+++ b/flink-libraries/flink-table/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -0,0 +1,6340 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.validate;
+
+import org.apache.calcite.config.NullCollation;
+import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.linq4j.function.Function2;
+import org.apache.calcite.linq4j.function.Functions;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.prepare.Prepare;
+import org.apache.calcite.rel.type.DynamicRecordType;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.RelRecordType;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexPatternFieldRef;
+import org.apache.calcite.rex.RexVisitor;
+import org.apache.calcite.runtime.CalciteContextException;
+import org.apache.calcite.runtime.CalciteException;
+import org.apache.calcite.runtime.Feature;
+import org.apache.calcite.runtime.Resources;
+import org.apache.calcite.schema.ColumnStrategy;
+import org.apache.calcite.schema.Table;
+import org.apache.calcite.schema.impl.ModifiableViewTable;
+import org.apache.calcite.sql.JoinConditionType;
+import org.apache.calcite.sql.JoinType;
+import org.apache.calcite.sql.SqlAccessEnum;
+import org.apache.calcite.sql.SqlAccessType;
+import org.apache.calcite.sql.SqlBasicCall;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlCallBinding;
+import org.apache.calcite.sql.SqlDataTypeSpec;
+import org.apache.calcite.sql.SqlDelete;
+import org.apache.calcite.sql.SqlDynamicParam;
+import org.apache.calcite.sql.SqlExplain;
+import org.apache.calcite.sql.SqlFunction;
+import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlInsert;
+import org.apache.calcite.sql.SqlIntervalLiteral;
+import org.apache.calcite.sql.SqlIntervalQualifier;
+import org.apache.calcite.sql.SqlJoin;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
+import org.apache.calcite.sql.SqlMerge;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlOperatorTable;
+import org.apache.calcite.sql.SqlOrderBy;
+import org.apache.calcite.sql.SqlSampleSpec;
+import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.SqlSelectKeyword;
+import org.apache.calcite.sql.SqlSyntax;
+import org.apache.calcite.sql.SqlUnresolvedFunction;
+import org.apache.calcite.sql.SqlUpdate;
+import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.SqlWindow;
+import org.apache.calcite.sql.SqlWith;
+import org.apache.calcite.sql.SqlWithItem;
+import org.apache.calcite.sql.fun.SqlCase;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.AssignableOperandTypeChecker;
+import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlOperandTypeInference;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.sql.util.SqlBasicVisitor;
+import org.apache.calcite.sql.util.SqlShuttle;
+import org.apache.calcite.sql.util.SqlVisitor;
+import org.apache.calcite.sql2rel.InitializerContext;
+import org.apache.calcite.util.BitString;
+import org.apache.calcite.util.Bug;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.apache.calcite.util.ImmutableIntList;
+import org.apache.calcite.util.ImmutableNullableList;
+import org.apache.calcite.util.Litmus;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Static;
+import org.apache.calcite.util.Util;
+import org.apache.calcite.util.trace.CalciteTrace;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+import org.slf4j.Logger;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.AbstractList;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Supplier;
+
+import static org.apache.calcite.sql.SqlUtil.stripAs;
+import static org.apache.calcite.util.Static.RESOURCE;
+
+/*
+ * THIS FILE HAS BEEN COPIED FROM THE APACHE CALCITE PROJECT UNTIL CALCITE-2707 IS FIXED.
+ * (Added lines: 5937-5943)
+ */
+
+/**
+ * Default implementation of {@link SqlValidator}.
+ */
+public class SqlValidatorImpl implements SqlValidatorWithHints {
+ //~ Static fields/initializers ---------------------------------------------
+
+ public static final Logger TRACER = CalciteTrace.PARSER_LOGGER;
+
+ /**
+ * Alias generated for the source table when rewriting UPDATE to MERGE.
+ */
+ public static final String UPDATE_SRC_ALIAS = "SYS$SRC";
+
+ /**
+ * Alias generated for the target table when rewriting UPDATE to MERGE if no
+ * alias was specified by the user.
+ */
+ public static final String UPDATE_TGT_ALIAS = "SYS$TGT";
+
+ /**
+ * Alias prefix generated for source columns when rewriting UPDATE to MERGE.
+ */
+ public static final String UPDATE_ANON_PREFIX = "SYS$ANON";
+
+ //~ Instance fields --------------------------------------------------------
+
+ private final SqlOperatorTable opTab;
+ final SqlValidatorCatalogReader catalogReader;
+
+ /**
+ * Maps ParsePosition strings to the {@link SqlIdentifier} identifier
+ * objects at these positions
+ */
+ protected final Map<String, IdInfo> idPositions = new HashMap<>();
+
+ /**
+ * Maps {@link SqlNode query node} objects to the {@link SqlValidatorScope}
+ * scope created from them.
+ */
+ protected final Map<SqlNode, SqlValidatorScope> scopes =
+ new IdentityHashMap<>();
+
+ /**
+ * Maps a {@link SqlSelect} node to the scope used by its WHERE and HAVING
+ * clauses.
+ */
+ private final Map<SqlSelect, SqlValidatorScope> whereScopes =
+ new IdentityHashMap<>();
+
+ /**
+ * Maps a {@link SqlSelect} node to the scope used by its GROUP BY clause.
+ */
+ private final Map<SqlSelect, SqlValidatorScope> groupByScopes =
+ new IdentityHashMap<>();
+
+ /**
+ * Maps a {@link SqlSelect} node to the scope used by its SELECT and HAVING
+ * clauses.
+ */
+ private final Map<SqlSelect, SqlValidatorScope> selectScopes =
+ new IdentityHashMap<>();
+
+ /**
+ * Maps a {@link SqlSelect} node to the scope used by its ORDER BY clause.
+ */
+ private final Map<SqlSelect, SqlValidatorScope> orderScopes =
+ new IdentityHashMap<>();
+
+ /**
+ * Maps a {@link SqlSelect} node that is the argument to a CURSOR
+ * constructor to the scope of the result of that select node
+ */
+ private final Map<SqlSelect, SqlValidatorScope> cursorScopes =
+ new IdentityHashMap<>();
+
+ /**
+ * The name-resolution scope of a LATERAL TABLE clause.
+ */
+ private TableScope tableScope = null;
+
+ /**
+ * Maps a {@link SqlNode node} to the
+ * {@link SqlValidatorNamespace namespace} which describes what columns they
+ * contain.
+ */
+ protected final Map<SqlNode, SqlValidatorNamespace> namespaces =
+ new IdentityHashMap<>();
+
+ /**
+ * Set of select expressions used as cursor definitions. In standard SQL,
+ * only the top-level SELECT is a cursor; Calcite extends this with
+ * cursors as inputs to table functions.
+ */
+ private final Set<SqlNode> cursorSet = Sets.newIdentityHashSet();
+
+ /**
+ * Stack of objects that maintain information about function calls. A stack
+ * is needed to handle nested function calls. The function call currently
+ * being validated is at the top of the stack.
+ */
+ protected final Deque<FunctionParamInfo> functionCallStack =
+ new ArrayDeque<>();
+
+ private int nextGeneratedId;
+ protected final RelDataTypeFactory typeFactory;
+
+ /** The type of dynamic parameters until a type is imposed on them. */
+ protected final RelDataType unknownType;
+ private final RelDataType booleanType;
+
+ /**
+ * Map of derived RelDataType for each node. This is an IdentityHashMap
+ * since in some cases (such as null literals) we need to discriminate by
+ * instance.
+ */
+ private final Map<SqlNode, RelDataType> nodeToTypeMap =
+ new IdentityHashMap<>();
+ private final AggFinder aggFinder;
+ private final AggFinder aggOrOverFinder;
+ private final AggFinder aggOrOverOrGroupFinder;
+ private final AggFinder groupFinder;
+ private final AggFinder overFinder;
+ private final SqlConformance conformance;
+ private final Map<SqlNode, SqlNode> originalExprs = new HashMap<>();
+
+ private SqlNode top;
+
+ // REVIEW jvs 30-June-2006: subclasses may override shouldExpandIdentifiers
+ // in a way that ignores this; we should probably get rid of the protected
+ // method and always use this variable (or better, move preferences like
+ // this to a separate "parameter" class)
+ protected boolean expandIdentifiers;
+
+ protected boolean expandColumnReferences;
+
+ private boolean rewriteCalls;
+
+ private NullCollation nullCollation = NullCollation.HIGH;
+
+ // TODO jvs 11-Dec-2008: make this local to performUnconditionalRewrites
+ // if it's OK to expand the signature of that method.
+ private boolean validatingSqlMerge;
+
+ private boolean inWindow; // Allow nested aggregates
+
+ private final SqlValidatorImpl.ValidationErrorFunction validationErrorFunction =
+ new SqlValidatorImpl.ValidationErrorFunction();
+
+ //~ Constructors -----------------------------------------------------------
+
+ /**
+ * Creates a validator.
+ *
+ * @param opTab Operator table
+ * @param catalogReader Catalog reader
+ * @param typeFactory Type factory
+ * @param conformance Compatibility mode
+ */
+ protected SqlValidatorImpl(
+ SqlOperatorTable opTab,
+ SqlValidatorCatalogReader catalogReader,
+ RelDataTypeFactory typeFactory,
+ SqlConformance conformance) {
+ this.opTab = Objects.requireNonNull(opTab);
+ this.catalogReader = Objects.requireNonNull(catalogReader);
+ this.typeFactory = Objects.requireNonNull(typeFactory);
+ this.conformance = Objects.requireNonNull(conformance);
+
+ unknownType = typeFactory.createUnknownType();
+ booleanType = typeFactory.createSqlType(SqlTypeName.BOOLEAN);
+
+ rewriteCalls = true;
+ expandColumnReferences = true;
+ aggFinder = new AggFinder(opTab, false, true, false, null);
+ aggOrOverFinder = new AggFinder(opTab, true, true, false, null);
+ overFinder = new AggFinder(opTab, true, false, false, aggOrOverFinder);
+ groupFinder = new AggFinder(opTab, false, false, true, null);
+ aggOrOverOrGroupFinder = new AggFinder(opTab, true, true, true, null);
+ }
+
+ //~ Methods ----------------------------------------------------------------
+
+ public SqlConformance getConformance() {
+ return conformance;
+ }
+
+ public SqlValidatorCatalogReader getCatalogReader() {
+ return catalogReader;
+ }
+
+ public SqlOperatorTable getOperatorTable() {
+ return opTab;
+ }
+
+ public RelDataTypeFactory getTypeFactory() {
+ return typeFactory;
+ }
+
+ public RelDataType getUnknownType() {
+ return unknownType;
+ }
+
+ public SqlNodeList expandStar(
+ SqlNodeList selectList,
+ SqlSelect select,
+ boolean includeSystemVars) {
+ 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);
+ }
+
+ // implement SqlValidator
+ public void declareCursor(SqlSelect select, SqlValidatorScope parentScope) {
+ 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);
+ cursorScopes.put(select, cursorScope);
+ final SelectNamespace selectNs = createSelectNamespace(select, select);
+ String alias = deriveAlias(select, nextGeneratedId++);
+ registerNamespace(cursorScope, alias, selectNs, false);
+ }
+
+ // implement SqlValidator
+ public void pushFunctionCall() {
+ FunctionParamInfo funcInfo = new FunctionParamInfo();
+ functionCallStack.push(funcInfo);
+ }
+
+ // implement SqlValidator
+ public void popFunctionCall() {
+ functionCallStack.pop();
+ }
+
+ // implement SqlValidator
+ public String getParentCursor(String columnListParamName) {
+ FunctionParamInfo funcParamInfo = functionCallStack.peek();
+ Map<String, String> parentCursorMap =
+ funcParamInfo.columnListParamToParentCursorMap;
+ return parentCursorMap.get(columnListParamName);
+ }
+
+ /**
+ * If <code>selectItem</code> is "*" or "TABLE.*", expands it and returns
+ * true; otherwise writes the unexpanded item.
+ *
+ * @param selectItem Select-list item
+ * @param select Containing select clause
+ * @param selectItems List that expanded items are written to
+ * @param aliases Set of aliases
+ * @param fields List of field names and types, in alias order
+ * @param includeSystemVars If true include system vars in lists
+ * @return Whether the node was expanded
+ */
+ private boolean expandSelectItem(
+ final SqlNode selectItem,
+ SqlSelect select,
+ RelDataType targetType,
+ List<SqlNode> selectItems,
+ Set<String> aliases,
+ List<Map.Entry<String, RelDataType>> fields,
+ final boolean includeSystemVars) {
+ 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 = expand(selectItem, scope);
+ 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);
+
+ inferUnknownTypes(targetType, scope, expanded);
+ final RelDataType type = deriveType(selectScope, expanded);
+ setValidatedNodeType(expanded, type);
+ fields.add(Pair.of(alias, type));
+ return false;
+ }
+
+ private boolean expandStar(List<SqlNode> selectItems, Set<String> aliases,
+ List<Map.Entry<String, RelDataType>> fields, boolean includeSystemVars,
+ SelectScope scope, SqlNode node) {
+ 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;
+ }
+ }
+
+ private SqlNode maybeCast(SqlNode node, RelDataType currentType,
+ RelDataType desiredType) {
+ return currentType.equals(desiredType)
+ || (currentType.isNullable() != desiredType.isNullable()
+ && typeFactory.createTypeWithNullability(currentType,
+ desiredType.isNullable()).equals(desiredType))
+ ? node
+ : SqlStdOperatorTable.CAST.createCall(SqlParserPos.ZERO,
+ node, SqlTypeUtil.convertTypeToSpec(desiredType));
+ }
+
+ private boolean addOrExpandField(List<SqlNode> selectItems, Set<String> aliases,
+ List<Map.Entry<String, RelDataType>> fields, boolean includeSystemVars,
+ SelectScope scope, SqlIdentifier id, RelDataTypeField field) {
+ 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;
+ }
+
+ public SqlNode validate(SqlNode topNode) {
+ SqlValidatorScope scope = new EmptyScope(this);
+ scope = new CatalogScope(scope, ImmutableList.of("CATALOG"));
+ final SqlNode topNode2 = validateScopedExpression(topNode, scope);
+ final RelDataType type = getValidatedNodeType(topNode2);
+ Util.discard(type);
+ return topNode2;
+ }
+
+ public List<SqlMoniker> lookupHints(SqlNode topNode, SqlParserPos pos) {
+ 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);
+ }
+
+ public SqlMoniker lookupQualifiedName(SqlNode topNode, SqlParserPos pos) {
+ 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;
+ }
+ }
+
+ /**
+ * Looks up completion hints for a syntactically correct select SQL that has
+ * been parsed into an expression tree.
+ *
+ * @param select the Select node of the parsed expression tree
+ * @param pos indicates the position in the sql statement we want to get
+ * completion hints for
+ * @param hintList list of {@link SqlMoniker} (sql identifiers) that can
+ * fill in at the indicated position
+ */
+ void lookupSelectHints(
+ SqlSelect select,
+ SqlParserPos pos,
+ Collection<SqlMoniker> hintList) {
+ 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);
+ }
+ }
+
+ private void lookupSelectHints(
+ SqlValidatorNamespace ns,
+ SqlParserPos pos,
+ Collection<SqlMoniker> hintList) {
+ final SqlNode node = ns.getNode();
+ if (node instanceof SqlSelect) {
+ lookupSelectHints((SqlSelect) node, pos, hintList);
+ }
+ }
+
+ private void lookupFromHints(
+ SqlNode node,
+ SqlValidatorScope scope,
+ SqlParserPos pos,
+ Collection<SqlMoniker> hintList) {
+ 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;
+ }
+ }
+
+ private void lookupJoinHints(
+ SqlJoin join,
+ SqlValidatorScope scope,
+ SqlParserPos pos,
+ Collection<SqlMoniker> hintList) {
+ 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.
+ return;
+ }
+ }
+
+ /**
+ * Populates a list of all the valid alternatives for an identifier.
+ *
+ * @param scope Validation scope
+ * @param names Components of the identifier
+ * @param pos position
+ * @param hintList a list of valid options
+ */
+ public final void lookupNameCompletionHints(
+ SqlValidatorScope scope,
+ List<String> names,
+ SqlParserPos pos,
+ Collection<SqlMoniker> hintList) {
+ // 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();
+ 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);
+ }
+
+ private static void findAllValidUdfNames(
+ List<String> names,
+ SqlValidator validator,
+ Collection<SqlMoniker> result) {
+ final List<SqlMoniker> objNames = new ArrayList<>();
+ SqlValidatorUtil.getSchemaObjectMonikers(
+ validator.getCatalogReader(),
+ names,
+ objNames);
+ for (SqlMoniker objName : objNames) {
+ if (objName.getType() == SqlMonikerType.FUNCTION) {
+ result.add(objName);
+ }
+ }
+ }
+
+ private static void findAllValidFunctionNames(
+ List<String> names,
+ SqlValidator validator,
+ Collection<SqlMoniker> result,
+ SqlParserPos pos) {
+ // 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 =
+ SqlUtil.makeCall(
+ validator.getOperatorTable(),
+ 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.replaceAll("'", "");
+ result.add(
+ new SqlMonikerImpl(
+ sig,
+ SqlMonikerType.FUNCTION));
+ continue;
+ }
+ result.add(
+ new SqlMonikerImpl(
+ op.getName(),
+ SqlMonikerType.FUNCTION));
+ }
+ }
+ }
+ }
+
+ public SqlNode validateParameterizedExpression(
+ SqlNode topNode,
+ final Map<String, RelDataType> nameToTypeMap) {
+ SqlValidatorScope scope = new ParameterScope(this, nameToTypeMap);
+ return validateScopedExpression(topNode, scope);
+ }
+
+ private SqlNode validateScopedExpression(
+ SqlNode topNode,
+ SqlValidatorScope scope) {
+ SqlNode outermostNode = performUnconditionalRewrites(topNode, false);
+ cursorSet.add(outermostNode);
+ top = outermostNode;
+ TRACER.trace("After unconditional rewrite: {}", outermostNode);
+ if (outermostNode.isA(SqlKind.TOP_LEVEL)) {
+ registerQuery(scope, null, outermostNode, outermostNode, null, false);
+ }
+ outermostNode.validate(this, scope);
+ if (!outermostNode.isA(SqlKind.TOP_LEVEL)) {
+ // force type derivation so that we can provide it to the
+ // caller later without needing the scope
+ deriveType(scope, outermostNode);
+ }
+ TRACER.trace("After validation: {}", outermostNode);
+ return outermostNode;
+ }
+
+ public void validateQuery(SqlNode node, SqlValidatorScope scope,
+ RelDataType targetRowType) {
+ final SqlValidatorNamespace ns = getNamespace(node, scope);
+ if (node.getKind() == SqlKind.TABLESAMPLE) {
+ List<SqlNode> operands = ((SqlCall) node).getOperandList();
+ SqlSampleSpec sampleSpec = SqlLiteral.sampleValue(operands.get(1));
+ if (sampleSpec instanceof SqlSampleSpec.SqlTableSampleSpec) {
+ validateFeature(RESOURCE.sQLFeature_T613(), node.getParserPosition());
+ } else if (sampleSpec
+ instanceof SqlSampleSpec.SqlSubstitutionSampleSpec) {
+ validateFeature(RESOURCE.sQLFeatureExt_T613_Substitution(),
+ node.getParserPosition());
+ }
+ }
+
+ validateNamespace(ns, targetRowType);
+ switch (node.getKind()) {
+ case EXTEND:
+ // Until we have a dedicated namespace for EXTEND
+ deriveType(scope, node);
+ }
+ if (node == top) {
+ validateModality(node);
+ }
+ validateAccess(
+ node,
+ ns.getTable(),
+ SqlAccessEnum.SELECT);
+ }
+
+ /**
+ * Validates a namespace.
+ *
+ * @param namespace Namespace
+ * @param targetRowType Desired row type, must not be null, may be the data
+ * type 'unknown'.
+ */
+ protected void validateNamespace(final SqlValidatorNamespace namespace,
+ RelDataType targetRowType) {
+ namespace.validate(targetRowType);
+ if (namespace.getNode() != null) {
+ setValidatedNodeType(namespace.getNode(), namespace.getType());
+ }
+ }
+
+ @VisibleForTesting
+ public SqlValidatorScope getEmptyScope() {
+ return new EmptyScope(this);
+ }
+
+ public SqlValidatorScope getCursorScope(SqlSelect select) {
+ return cursorScopes.get(select);
+ }
+
+ public SqlValidatorScope getWhereScope(SqlSelect select) {
+ return whereScopes.get(select);
+ }
+
+ public SqlValidatorScope getSelectScope(SqlSelect select) {
+ return selectScopes.get(select);
+ }
+
+ public SelectScope getRawSelectScope(SqlSelect select) {
+ SqlValidatorScope scope = getSelectScope(select);
+ if (scope instanceof AggregatingSelectScope) {
+ scope = ((AggregatingSelectScope) scope).getParent();
+ }
+ return (SelectScope) scope;
+ }
+
+ public SqlValidatorScope getHavingScope(SqlSelect select) {
+ // Yes, it's the same as getSelectScope
+ return selectScopes.get(select);
+ }
+
+ public SqlValidatorScope getGroupScope(SqlSelect select) {
+ // Yes, it's the same as getWhereScope
+ return groupByScopes.get(select);
+ }
+
+ public SqlValidatorScope getFromScope(SqlSelect select) {
+ return scopes.get(select);
+ }
+
+ public SqlValidatorScope getOrderScope(SqlSelect select) {
+ return orderScopes.get(select);
+ }
+
+ public SqlValidatorScope getMatchRecognizeScope(SqlMatchRecognize node) {
+ return scopes.get(node);
+ }
+
+ public SqlValidatorScope getJoinScope(SqlNode node) {
+ return scopes.get(stripAs(node));
+ }
+
+ public SqlValidatorScope getOverScope(SqlNode node) {
+ return scopes.get(node);
+ }
+
+ private SqlValidatorNamespace getNamespace(SqlNode node,
+ SqlValidatorScope scope) {
+ 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 EXTEND:
+ final SqlIdentifier id = (SqlIdentifier) call.getOperandList().get(0);
+ final DelegatingScope idScope = (DelegatingScope) scope;
+ return getNamespace(id, idScope);
+ case AS:
+ final SqlNode nested = call.getOperandList().get(0);
+ switch (nested.getKind()) {
+ case EXTEND:
+ return getNamespace(nested, scope);
+ }
+ break;
+ }
+ }
+ return getNamespace(node);
+ }
+
+ private SqlValidatorNamespace getNamespace(SqlIdentifier id, DelegatingScope scope) {
+ 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);
+ }
+
+ public SqlValidatorNamespace getNamespace(SqlNode node) {
+ 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 OVER:
+ case COLLECTION_TABLE:
+ case ORDER_BY:
+ case TABLESAMPLE:
+ return getNamespace(((SqlCall) node).operand(0));
+ default:
+ return namespaces.get(node);
+ }
+ }
+
+ private void handleOffsetFetch(SqlNode offset, SqlNode fetch) {
+ if (offset instanceof SqlDynamicParam) {
+ setValidatedNodeType(offset,
+ typeFactory.createSqlType(SqlTypeName.INTEGER));
+ }
+ if (fetch instanceof SqlDynamicParam) {
+ setValidatedNodeType(fetch,
+ typeFactory.createSqlType(SqlTypeName.INTEGER));
+ }
+ }
+
+ /**
+ * 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.
+ *
+ * @param node expression to be rewritten
+ * @param underFrom whether node appears directly under a FROM clause
+ * @return rewritten expression
+ */
+ protected SqlNode performUnconditionalRewrites(
+ SqlNode node,
+ boolean underFrom) {
+ if (node == null) {
+ return node;
+ }
+
+ 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);
+ if (overloads.size() == 1) {
+ ((SqlBasicCall) call).setOperator(overloads.get(0));
+ }
+ }
+ if (rewriteCalls) {
+ 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);
+ }
+
+ 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);
+ }
+
+ 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);
+ }
+
+ 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;
+ }
+
+ private SqlSelect getInnerSelect(SqlNode node) {
+ 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;
+ }
+ }
+ }
+
+ private void rewriteMerge(SqlMerge call) {
+ SqlNodeList selectList;
+ SqlUpdate updateStmt = call.getUpdateCall();
+ if (updateStmt != null) {
+ // if we have an update statement, just clone the select list
+ // from the update statement's source since it's the same as
+ // what we want for the select list of the merge source -- '*'
+ // followed by the update set expressions
+ selectList = SqlNode.clone(updateStmt.getSourceSelect().getSelectList());
+ } else {
+ // otherwise, just use select *
+ selectList = new SqlNodeList(SqlParserPos.ZERO);
+ selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
+ }
+ SqlNode targetTable = call.getTargetTable();
+ if (call.getAlias() != null) {
+ targetTable =
+ SqlValidatorUtil.addAlias(
+ targetTable,
+ call.getAlias().getSimple());
+ }
+
+ // Provided there is an insert substatement, the source select for
+ // the merge is a left outer join between the source in the USING
+ // clause and the target table; otherwise, the join is just an
+ // inner join. Need to clone the source table reference in order
+ // for validation to work
+ SqlNode sourceTableRef = call.getSourceTableRef();
+ SqlInsert insertCall = call.getInsertCall();
+ JoinType joinType = (insertCall == null) ? JoinType.INNER : JoinType.LEFT;
+ final SqlNode leftJoinTerm = SqlNode.clone(sourceTableRef);
+ SqlNode outerJoin =
+ new SqlJoin(SqlParserPos.ZERO,
+ leftJoinTerm,
+ SqlLiteral.createBoolean(false, SqlParserPos.ZERO),
+ joinType.symbol(SqlParserPos.ZERO),
+ targetTable,
+ JoinConditionType.ON.symbol(SqlParserPos.ZERO),
+ call.getCondition());
+ SqlSelect select =
+ new SqlSelect(SqlParserPos.ZERO, null, selectList, outerJoin, null,
+ null, null, null, null, null, null);
+ call.setSourceSelect(select);
+
+ // Source for the insert call is a select of the source table
+ // reference with the select list being the value expressions;
+ // note that the values clause has already been converted to a
+ // select on the values row constructor; so we need to extract
+ // that via the from clause on the select
+ if (insertCall != null) {
+ SqlCall valuesCall = (SqlCall) insertCall.getSource();
+ SqlCall rowCall = valuesCall.operand(0);
+ selectList =
+ new SqlNodeList(
+ rowCall.getOperandList(),
+ SqlParserPos.ZERO);
+ final SqlNode insertSource = SqlNode.clone(sourceTableRef);
+ select =
+ new SqlSelect(SqlParserPos.ZERO, null, selectList, insertSource, null,
+ null, null, null, null, null, null);
+ insertCall.setSource(select);
+ }
+ }
+
+ private SqlNode rewriteUpdateToMerge(
+ SqlUpdate updateCall,
+ SqlNode selfJoinSrcExpr) {
+ // Make sure target has an alias.
+ if (updateCall.getAlias() == null) {
+ updateCall.setAlias(
+ new SqlIdentifier(UPDATE_TGT_ALIAS, SqlParserPos.ZERO));
+ }
+ SqlNode selfJoinTgtExpr =
+ getSelfJoinExprForUpdate(
+ updateCall.getTargetTable(),
+ updateCall.getAlias().getSimple());
+ assert selfJoinTgtExpr != null;
+
+ // Create join condition between source and target exprs,
+ // creating a conjunction with the user-level WHERE
+ // clause if one was supplied
+ SqlNode condition = updateCall.getCondition();
+ SqlNode selfJoinCond =
+ SqlStdOperatorTable.EQUALS.createCall(
+ SqlParserPos.ZERO,
+ selfJoinSrcExpr,
+ selfJoinTgtExpr);
+ if (condition == null) {
+ condition = selfJoinCond;
+ } else {
+ condition =
+ SqlStdOperatorTable.AND.createCall(
+ SqlParserPos.ZERO,
+ selfJoinCond,
+ condition);
+ }
+ SqlNode target =
+ updateCall.getTargetTable().clone(SqlParserPos.ZERO);
+
+ // For the source, we need to anonymize the fields, so
+ // that for a statement like UPDATE T SET I = I + 1,
+ // there's no ambiguity for the "I" in "I + 1";
+ // this is OK because the source and target have
+ // identical values due to the self-join.
+ // Note that we anonymize the source rather than the
+ // target because downstream, the optimizer rules
+ // don't want to see any projection on top of the target.
+ IdentifierNamespace ns =
+ new IdentifierNamespace(this, target, null, null);
+ RelDataType rowType = ns.getRowType();
+ SqlNode source = updateCall.getTargetTable().clone(SqlParserPos.ZERO);
+ final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
+ int i = 1;
+ for (RelDataTypeField field : rowType.getFieldList()) {
+ SqlIdentifier col =
+ new SqlIdentifier(
+ field.getName(),
+ SqlParserPos.ZERO);
+ selectList.add(
+ SqlValidatorUtil.addAlias(col, UPDATE_ANON_PREFIX + i));
+ ++i;
+ }
+ source =
+ new SqlSelect(SqlParserPos.ZERO, null, selectList, source, null, null,
+ null, null, null, null, null);
+ source = SqlValidatorUtil.addAlias(source, UPDATE_SRC_ALIAS);
+ SqlMerge mergeCall =
+ new SqlMerge(updateCall.getParserPosition(), target, condition, source,
+ updateCall, null, null, updateCall.getAlias());
+ rewriteMerge(mergeCall);
+ return mergeCall;
+ }
+
+ /**
+ * 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.
+ *
+ * @param table identifier for table being updated
+ * @param alias alias to use for qualifying columns in expression, or null
+ * for unqualified references; if this is equal to
+ * {@value #UPDATE_SRC_ALIAS}, then column references have been
+ * anonymized to "SYS$ANONx", where x is the 1-based column
+ * number.
+ * @return expression for unique identifier, or null to prevent conversion
+ */
+ protected SqlNode getSelfJoinExprForUpdate(
+ SqlNode table,
+ String alias) {
+ return null;
+ }
+
+ /**
+ * Creates the SELECT statement that putatively feeds rows into an UPDATE
+ * statement to be updated.
+ *
+ * @param call Call to the UPDATE operator
+ * @return select statement
+ */
+ protected SqlSelect createSourceSelectForUpdate(SqlUpdate call) {
+ 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);
+ }
+
+ /**
+ * Creates the SELECT statement that putatively feeds rows into a DELETE
+ * statement to be deleted.
+ *
+ * @param call Call to the DELETE operator
+ * @return select statement
+ */
+ protected SqlSelect createSourceSelectForDelete(SqlDelete call) {
+ 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);
+ }
+
+ /**
+ * Returns null if there is no common type. E.g. if the rows have a
+ * different number of columns.
+ */
+ RelDataType getTableConstructorRowType(
+ SqlCall values,
+ SqlValidatorScope scope) {
+ 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);
+ }
+
+ public RelDataType getValidatedNodeType(SqlNode node) {
+ RelDataType type = getValidatedNodeTypeIfKnown(node);
+ if (type == null) {
+ throw Util.needToImplement(node);
+ } else {
+ return type;
+ }
+ }
+
+ public RelDataType getValidatedNodeTypeIfKnown(SqlNode node) {
+ 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;
+ }
+
+ /**
+ * Saves the type of a {@link SqlNode}, now that it has been validated.
+ *
+ * <p>Unlike the base class method, this method is not deprecated.
+ * It is available from within Calcite, but is not part of the public API.
+ *
+ * @param node A SQL parse tree node, never null
+ * @param type Its type; must not be null
+ */
+ @SuppressWarnings("deprecation")
+ public final void setValidatedNodeType(SqlNode node, RelDataType type) {
+ Objects.requireNonNull(type);
+ Objects.requireNonNull(node);
+ if (type.equals(unknownType)) {
+ // don't set anything until we know what it is, and don't overwrite
+ // a known type with the unknown type
+ return;
+ }
+ nodeToTypeMap.put(node, type);
+ }
+
+ public void removeValidatedNodeType(SqlNode node) {
+ nodeToTypeMap.remove(node);
+ }
+
+ public RelDataType deriveType(
+ SqlValidatorScope scope,
+ SqlNode expr) {
+ 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;
+ }
+
+ /**
+ * Derives the type of a node, never null.
+ */
+ RelDataType deriveTypeImpl(
+ SqlValidatorScope scope,
+ SqlNode operand) {
+ DeriveTypeVisitor v = new DeriveTypeVisitor(scope);
+ final RelDataType type = operand.accept(v);
+ return Objects.requireNonNull(scope.nullifyType(operand, type));
+ }
+
+ public RelDataType deriveConstructorType(
+ SqlValidatorScope scope,
+ SqlCall call,
+ SqlFunction unresolvedConstructor,
+ SqlFunction resolvedConstructor,
+ List<RelDataType> argTypes) {
+ 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 (shouldExpandIdentifiers()) {
+ 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;
+ }
+
+ public CalciteException handleUnresolvedFunction(SqlCall call,
+ SqlFunction unresolvedFunction, List<RelDataType> argTypes,
+ List<String> argNames) {
+ // For builtins, we can give a better error message
+ final List<SqlOperator> overloads = new ArrayList<>();
+ opTab.lookupOperatorOverloads(unresolvedFunction.getNameAsId(), null,
+ SqlSyntax.FUNCTION, overloads);
+ 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));
+ }
+
+ protected void inferUnknownTypes(
+ RelDataType inferredType,
+ SqlValidatorScope scope,
+ SqlNode 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) {
+ 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 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()];
+ if (operandTypeInference == null) {
+ // TODO: eventually should assert(operandTypeInference != null)
+ // instead; for now just eat it
+ Arrays.fill(operandTypes, unknownType);
+ } else {
+ operandTypeInference.inferOperandTypes(
+ callBinding,
+ inferredType,
+ operandTypes);
+ }
+ for (int i = 0; i < operands.size(); ++i) {
+ inferUnknownTypes(operandTypes[i], scope, operands.get(i));
+ }
+ }
+ }
+
+ /**
+ * Adds an expression to a select list, ensuring that its alias does not
+ * clash with any existing expressions on the list.
+ */
+ protected void addToSelectList(
+ List<SqlNode> list,
+ Set<String> aliases,
+ List<Map.Entry<String, RelDataType>> fieldList,
+ SqlNode exp,
+ SqlValidatorScope scope,
+ final boolean includeSystemVars) {
+ String alias = SqlValidatorUtil.getAlias(exp, -1);
+ String uniqueAlias =
+ SqlValidatorUtil.uniquify(
+ alias, aliases, SqlValidatorUtil.EXPR_SUGGESTER);
+ if (!alias.equals(uniqueAlias)) {
+ exp = SqlValidatorUtil.addAlias(exp, uniqueAlias);
+ }
+ fieldList.add(Pair.of(uniqueAlias, deriveType(scope, exp)));
+ list.add(exp);
+ }
+
+ public String deriveAlias(
+ SqlNode node,
+ int ordinal) {
+ return SqlValidatorUtil.getAlias(node, ordinal);
+ }
+
+ // implement SqlValidator
+ public void setIdentifierExpansion(boolean expandIdentifiers) {
+ this.expandIdentifiers = expandIdentifiers;
+ }
+
+ // implement SqlValidator
+ public void setColumnReferenceExpansion(
+ boolean expandColumnReferences) {
+ this.expandColumnReferences = expandColumnReferences;
+ }
+
+ // implement SqlValidator
+ public boolean getColumnReferenceExpansion() {
+ return expandColumnReferences;
+ }
+
+ public void setDefaultNullCollation(NullCollation nullCollation) {
+ this.nullCollation = Objects.requireNonNull(nullCollation);
+ }
+
+ public NullCollation getDefaultNullCollation() {
+ return nullCollation;
+ }
+
+ // implement SqlValidator
+ public void setCallRewrite(boolean rewriteCalls) {
+ this.rewriteCalls = rewriteCalls;
+ }
+
+ public boolean shouldExpandIdentifiers() {
+ return expandIdentifiers;
+ }
+
+ protected boolean shouldAllowIntermediateOrderBy() {
+ return true;
+ }
+
+ private void registerMatchRecognize(
+ SqlValidatorScope parentScope,
+ SqlValidatorScope usingScope,
+ SqlMatchRecognize call,
+ SqlNode enclosingNode,
+ String alias,
+ boolean forceNullable) {
+
+ 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);
+ }
+ }
+
+ protected MatchRecognizeNamespace createMatchRecognizeNameSpace(
+ SqlMatchRecognize call,
+ SqlNode enclosingNode) {
+ return new MatchRecognizeNamespace(this, call, enclosingNode);
+ }
+
+ /**
+ * 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.
+ *
+ * @param usingScope Parent scope (which will want to look for things in
+ * this namespace)
+ * @param alias Alias by which parent will refer to this namespace
+ * @param ns Namespace
+ * @param forceNullable Whether to force the type of namespace to be nullable
+ */
+ protected void registerNamespace(
+ SqlValidatorScope usingScope,
+ String alias,
+ SqlValidatorNamespace ns,
+ boolean forceNullable) {
+ namespaces.put(ns.getNode(), ns);
+ if (usingScope != null) {
+ usingScope.addChild(ns, alias, forceNullable);
+ }
+ }
+
+ /**
+ * Registers scopes and namespaces implied a relational expression in the
+ * FROM clause.
+ *
+ * <p>{@code parentScope} and {@code usingScope} are often the same. They
+ * differ when the namespace are not visible within the parent. (Example
+ * needed.)
+ *
+ * <p>Likewise, {@code enclosingNode} and {@code node} are often the same.
+ * {@code enclosingNode} is the topmost node within the FROM clause, from
+ * which any decorations like an alias (<code>AS alias</code>) or a table
+ * sample clause are stripped away to get {@code node}. Both are recorded in
+ * the namespace.
+ *
+ * @param parentScope Parent scope which this scope turns to in order to
+ * resolve objects
+ * @param usingScope Scope whose child list this scope should add itself to
+ * @param register Whether to register this scope as a child of
+ * {@code usingScope}
+ * @param node Node which namespace is based on
+ * @param enclosingNode Outermost node for namespace, including decorations
+ * such as alias and sample clause
+ * @param alias Alias
+ * @param extendList Definitions of extended columns
+ * @param forceNullable Whether to force the type of namespace to be
+ * nullable because it is in an outer join
+ * @param lateral Whether LATERAL is specified, so that items to the
+ * left of this in the JOIN tree are visible in the
+ * scope
+ * @return registered node, usually the same as {@code node}
+ */
+ private SqlNode registerFrom(
+ SqlValidatorScope parentScope,
+ SqlValidatorScope usingScope,
+ boolean register,
+ final SqlNode node,
+ SqlNode enclosingNode,
+ String alias,
+ SqlNodeList extendList,
+ boolean forceNullable,
+ final boolean lateral) {
+ 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 (shouldExpandIdentifiers()) {
+ 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 (shouldExpandIdentifiers()) {
+ // 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();
+ final boolean rightIsLateral = isLateral(right);
+ 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);
+ }
+ scopes.put(node, parentScope);
+ 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 EXTEND:
+ final SqlCall extend = (SqlCall) node;
+ return registerFrom(parentScope,
+ usingScope,
+ true,
+ extend.getOperandList().get(0),
+ extend,
+ alias,
+ (SqlNodeList) extend.getOperandList().get(1),
+ forceNullable,
+ lateral);
+
+ default:
+ throw Util.unexpected(kind);
+ }
+ }
+
+ private static boolean isLateral(SqlNode node) {
+ switch (node.getKind()) {
+ case LATERAL:
+ case UNNEST:
+ // Per SQL std, UNNEST is implicitly LATERAL.
+ return true;
+ case AS:
+ return isLateral(((SqlCall) node).operand(0));
+ default:
+ return false;
+ }
+ }
+
+ protected boolean shouldAllowOverRelation() {
+ return false;
+ }
+
+ /**
+ * Creates a namespace for a <code>SELECT</code> node. Derived class may
+ * override this factory method.
+ *
+ * @param select Select node
+ * @param enclosingNode Enclosing node
+ * @return Select namespace
+ */
+ protected SelectNamespace createSelectNamespace(
+ SqlSelect select,
+ SqlNode enclosingNode) {
+ return new SelectNamespace(this, select, enclosingNode);
+ }
+
+ /**
+ * Creates a namespace for a set operation (<code>UNION</code>, <code>
+ * INTERSECT</code>, or <code>EXCEPT</code>). Derived class may override
+ * this factory method.
+ *
+ * @param call Call to set operation
+ * @param enclosingNode Enclosing node
+ * @return Set operation namespace
+ */
+ protected SetopNamespace createSetopNamespace(
+ SqlCall call,
+ SqlNode enclosingNode) {
+ return new SetopNamespace(this, call, enclosingNode);
+ }
+
+ /**
+ * Registers a query in a parent scope.
+ *
+ * @param parentScope Parent scope which this scope turns to in order to
+ * resolve objects
+ * @param usingScope Scope whose child list this scope should add itself to
+ * @param node Query node
+ * @param alias Name of this query within its parent. Must be specified
+ * if usingScope != null
+ */
+ private void registerQuery(
+ SqlValidatorScope parentScope,
+ SqlValidatorScope usingScope,
+ SqlNode node,
+ SqlNode enclosingNode,
+ String alias,
+ boolean forceNullable) {
+ Preconditions.checkArgument(usingScope == null || alias != null);
+ registerQuery(
+ parentScope,
+ usingScope,
+ node,
+ enclosingNode,
+ alias,
+ forceNullable,
+ true);
+ }
+
+ /**
+ * Registers a query in a parent scope.
+ *
+ * @param parentScope Parent scope which this scope turns to in order to
+ * resolve objects
+ * @param usingScope Scope whose child list this scope should add itself to
+ * @param node Query node
+ * @param alias Name of this query within its parent. Must be specified
+ * if usingScope != null
+ * @param checkUpdate if true, validate that the update feature is supported
+ * if validating the update statement
+ */
+ private void registerQuery(
+ SqlValidatorScope parentScope,
+ SqlValidatorScope usingScope,
+ SqlNode node,
+ SqlNode enclosingNode,
+ String alias,
+ boolean forceNullable,
+ boolean checkUpdate) {
+ 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
+ whereScopes.put(select, 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);
+ selectScopes.put(select, aggScope);
+ } else {
+ selectScopes.put(select, selectScope);
+ }
+ if (select.getGroup() != null) {
+ GroupByScope groupByScope =
+ new GroupByScope(selectScope, select.getGroup(), select);
+ groupByScopes.put(select, 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);
+ orderScopes.put(select, 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(
+ whereScopes.get(mergeCall.getSourceSelect()),
+ 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());
+ }
+ }
+
+ private void registerSetop(
+ SqlValidatorScope parentScope,
+ SqlValidatorScope usingScope,
+ SqlNode node,
+ SqlNode enclosingNode,
+ String alias,
+ boolean forceNullable) {
+ SqlCall call = (SqlCall) node;
+ final SetopNamespace setopNamespace =
+ createSetopNamespace(call, enclosingNode);
+ registerNamespace(usingScope, alias, setopNamespace, forceNullable);
+
+ // A setop is in the same scope as its parent.
+ scopes.put(call, parentScope);
+ for (SqlNode operand : call.getOperandList()) {
+ registerQuery(
+ parentScope,
+ null,
+ operand,
+ operand,
+ null,
+ false);
+ }
+ }
+
+ private void registerWith(
+ SqlValidatorScope parentScope,
+ SqlValidatorScope usingScope,
+ SqlWith with,
+ SqlNode enclosingNode,
+ String alias,
+ boolean forceNullable,
+ boolean checkUpdate) {
+ final WithNamespace withNamespace =
+ new WithNamespace(this, with, enclosingNode);
+ registerNamespace(usingScope, alias, withNamespace, forceNullable);
+
+ SqlValidatorScope scope = parentScope;
+ for (SqlNode withItem_ : with.withList) {
+ final SqlWithItem withItem = (SqlWithItem) withItem_;
+ final WithScope withScope = new WithScope(scope, withItem);
+ scopes.put(withItem, withScope);
+
+ registerQuery(scope, null, withItem.query, with,
+ withItem.name.getSimple(), false);
+ registerNamespace(null, alias,
+ new WithItemNamespace(this, withItem, enclosingNode),
+ false);
+ scope = withScope;
+ }
+
+ registerQuery(scope, null, with.body, enclosingNode, alias, forceNullable,
+ checkUpdate);
+ }
+
+ public boolean isAggregate(SqlSelect select) {
+ 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;
+ }
+
+ protected boolean isNestedAggregateWindow(SqlNode node) {
+ AggFinder nestedAggFinder =
+ new AggFinder(opTab, false, false, false, aggFinder);
+ return nestedAggFinder.findAgg(node) != null;
+ }
+
+ protected boolean isOverAggregateWindow(SqlNode node) {
+ return aggFinder.findAgg(node) != null;
+ }
+
+ /** Returns the parse tree node (GROUP BY, HAVING, or an aggregate function
+ * call) that causes {@code select} to be an aggregate query, or null if it
+ * is not an aggregate query.
+ *
+ * <p>The node is useful context for error messages,
+ * but you cannot assume that the node is the only aggregate function. */
+ protected SqlNode getAggregate(SqlSelect select) {
+ SqlNode node = select.getGroup();
+ if (node != null) {
+ return node;
+ }
+ node = select.getHaving();
+ if (node != null) {
+ return node;
+ }
+ return getAgg(select);
+ }
+
+ /** If there is at least one call to an aggregate function, returns the
+ * first. */
+ private SqlNode getAgg(SqlSelect select) {
+ 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());
+ }
+
+ @SuppressWarnings("deprecation")
+ public boolean isAggregate(SqlNode selectNode) {
+ return aggFinder.findAgg(selectNode) != null;
+ }
+
+ private void validateNodeFeature(SqlNode node) {
+ switch (node.getKind()) {
+ case MULTISET_VALUE_CONSTRUCTOR:
+ validateFeature(RESOURCE.sQLFeature_S271(), node.getParserPosition());
+ break;
+ }
+ }
+
+ private void registerSubQueries(
+ SqlValidatorScope parentScope,
+ SqlNode node) {
+ if (node == null) {
+ return;
+ }
+ if (node.getKind().belongsTo(SqlKind.QUERY)
+ || node.getKind() == SqlKind.MULTISET_QUERY_CONSTRUCTOR
+ || node.getKind() == SqlKind.MULTISET_VALUE_CONSTRUCTOR) {
+ registerQuery(parentScope, null, node, node, null, false);
+ } else if (node instanceof SqlCall) {
+ validateNodeFeature(node);
+ SqlCall call = (SqlCall) node;
+ for (int i = 0; i < call.operandCount(); i++) {
+ registerOperandSubQueries(parentScope, call, i);
+ }
+ } else if (node instanceof SqlNodeList) {
+ SqlNodeList list = (SqlNodeList) node;
+ for (int i = 0, count = list.size(); i < count; i++) {
+ SqlNode listNode = list.get(i);
+ if (listNode.getKind().belongsTo(SqlKind.QUERY)) {
+ listNode =
+ SqlStdOperatorTable.SCALAR_QUERY.createCall(
+ listNode.getParserPosition(),
+ listNode);
+ list.set(i, listNode);
+ }
+ registerSubQueries(parentScope, listNode);
+ }
+ } else {
+ // atomic node -- can be ignored
+ }
+ }
+
+ /**
+ * Registers any sub-queries inside a given call operand, and converts the
+ * operand to a scalar sub-query if the operator requires it.
+ *
+ * @param parentScope Parent scope
+ * @param call Call
+ * @param operandOrdinal Ordinal of operand within call
+ * @see SqlOperator#argumentMustBeScalar(int)
+ */
+ private void registerOperandSubQueries(
+ SqlValidatorScope parentScope,
+ SqlCall call,
+ int operandOrdinal) {
+ 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);
+ }
+
+ public void validateIdentifier(SqlIdentifier id, SqlValidatorScope scope) {
+ final SqlQualified fqId = scope.fullyQualify(id);
+ if (expandColumnReferences) {
+ // NOTE jvs 9-Apr-2007: this doesn't cover ORDER BY, which has its
+ // own ideas about qualification.
+ id.assignNamesFrom(fqId.identifier);
+ } else {
+ Util.discard(fqId);
+ }
+ }
+
+ public void validateLiteral(SqlLiteral literal) {
+ switch (literal.getTypeName()) {
+ case DECIMAL:
+ // Decimal and long have the same precision (as 64-bit integers), so
+ // the unscaled value of a decimal must fit into a long.
+
+ // REVIEW jvs 4-Aug-2004: This should probably be calling over to
+ // the available calculator implementations to see what they
+ // support. For now use ESP instead.
+ //
+ // jhyde 2006/12/21: I think the limits should be baked into the
+ // type system, not dependent on the calculator implementation.
+ BigDecimal bd = (BigDecimal) literal.getValue();
+ BigInteger unscaled = bd.unscaledValue();
+ long longValue = unscaled.longValue();
+ if (!BigInteger.valueOf(longValue).equals(unscaled)) {
+ // overflow
+ throw newValidationError(literal,
+ RESOURCE.numberLiteralOutOfRange(bd.toString()));
+ }
+ break;
+
+ case DOUBLE:
+ validateLiteralAsDouble(literal);
+ break;
+
+ case BINARY:
+ final BitString bitString = (BitString) literal.getValue();
+ if ((bitString.getBitCount() % 8) != 0) {
+ throw newValidationError(literal, RESOURCE.binaryLiteralOdd());
+ }
+ break;
+
+ case DATE:
+ case TIME:
+ case TIMESTAMP:
+ Calendar calendar = literal.getValueAs(Calendar.class);
+ final int year = calendar.get(Calendar.YEAR);
+ final int era = calendar.get(Calendar.ERA);
+ if (year < 1 || era == GregorianCalendar.BC || year > 9999) {
+ throw newValidationError(literal,
+ RESOURCE.dateLiteralOutOfRange(literal.toString()));
+ }
+ break;
+
+ case INTERVAL_YEAR:
+ case INTERVAL_YEAR_MONTH:
+ case INTERVAL_MONTH:
+ case INTERVAL_DAY:
+ case INTERVAL_DAY_HOUR:
+ case INTERVAL_DAY_MINUTE:
+ case INTERVAL_DAY_SECOND:
+ case INTERVAL_HOUR:
+ case INTERVAL_HOUR_MINUTE:
+ case INTERVAL_HOUR_SECOND:
+ case INTERVAL_MINUTE:
+ case INTERVAL_MINUTE_SECOND:
+ case INTERVAL_SECOND:
+ if (literal instanceof SqlIntervalLiteral) {
+ SqlIntervalLiteral.IntervalValue interval =
+ (SqlIntervalLiteral.IntervalValue)
+ literal.getValue();
+ SqlIntervalQualifier intervalQualifier =
+ interval.getIntervalQualifier();
+
+ // ensure qualifier is good before attempting to validate literal
+ validateIntervalQualifier(intervalQualifier);
+ String intervalStr = interval.getIntervalLiteral();
+ // throws CalciteContextException if string is invalid
+ int[] values = intervalQualifier.evaluateIntervalLiteral(intervalStr,
+ literal.getParserPosition(), typeFactory.getTypeSystem());
+ Util.discard(values);
+ }
+ break;
+ default:
+ // default is to do nothing
+ }
+ }
+
+ private void validateLiteralAsDouble(SqlLiteral literal) {
+ BigDecimal bd = (BigDecimal) literal.getValue();
+ double d = bd.doubleValue();
+ if (Double.isInfinite(d) || Double.isNaN(d)) {
+ // overflow
+ throw newValidationError(literal,
+ RESOURCE.numberLiteralOutOfRange(Util.toScientificNotation(bd)));
+ }
+
+ // REVIEW jvs 4-Aug-2004: what about underflow?
+ }
+
+ public void validateIntervalQualifier(SqlIntervalQualifier qualifier) {
+ assert qualifier != null;
+ boolean startPrecisionOutOfRange = false;
+ boolean fractionalSecondPrecisionOutOfRange = false;
+ final RelDataTypeSystem typeSystem = typeFactory.getTypeSystem();
+
+ final int startPrecision = qualifier.getStartPrecision(typeSystem);
+ final int fracPrecision =
+ qualifier.getFractionalSecondPrecision(typeSystem);
+ final int maxPrecision = typeSystem.getMaxPrecision(qualifier.typeName());
+ final int minPrecision = qualifier.typeName().getMinPrecision();
+ final int minScale = qualifier.typeName().getMinScale();
+ final int maxScale = typeSystem.getMaxScale(qualifier.typeName());
+ if (qualifier.isYearMonth()) {
+ if (startPrecision < minPrecision || startPrecision > maxPrecision) {
+ startPrecisionOutOfRange = true;
+ } else {
+ if (fracPrecision < minScale || fracPrecision > maxScale) {
+ fractionalSecondPrecisionOutOfRange = true;
+ }
+ }
+ } else {
+ if (startPrecision < minPrecision || startPrecision > maxPrecision) {
+ startPrecisionOutOfRange = true;
+ } else {
+ if (fracPrecision < minScale || fracPrecision > maxScale) {
+ fractionalSecondPrecisionOutOfRange = true;
+ }
+ }
+ }
+
+ if (startPrecisionOutOfRange) {
+ throw newValidationError(qualifier,
+ RESOURCE.intervalStartPrecisionOutOfRange(startPrecision,
+ "INTERVAL " + qualifier));
+ } else if (fractionalSecondPrecisionOutOfRange) {
+ throw newValidationError(qualifier,
+ RESOURCE.intervalFractionalSecondPrecisionOutOfRange(
+ fracPrecision,
+ "INTERVAL " + qualifier));
+ }
+ }
+
+ /**
+ * Validates the FROM clause of a query, or (recursively) a child node of
+ * the FROM clause: AS, OVER, JOIN, VALUES, or sub-query.
+ *
+ * @param node Node in FROM clause, typically a table or derived
+ * table
+ * @param targetRowType Desired row type of this expression, or
+ * {@link #unknownType} if not fussy. Must not be null.
+ * @param scope Scope
+ */
+ protected void validateFrom(
+ SqlNode node,
+ RelDataType targetRowType,
+ SqlValidatorScope scope) {
+ Objects.requireNonNull(targetRowType);
+ switch (node.getKind()) {
+ case AS:
+ validateFrom(
+ ((SqlCall) node).operand(0),
+ targetRowType,
+ scope);
+ break;
+ case VALUES:
+ validateValues((SqlCall) node, targetRowType, scope);
+ break;
+ case JOIN:
+ validateJoin((SqlJoin) node, scope);
+ break;
+ case OVER:
+ validateOver((SqlCall) node, scope);
+ break;
+ default:
+ validateQuery(node, scope, targetRowType);
+ break;
+ }
+
+ // Validate the namespace representation of the node, just in case the
+ // validation did not occur implicitly.
+ getNamespace(node, scope).validate(targetRowType);
+ }
+
+ protected void validateOver(SqlCall call, SqlValidatorScope scope) {
+ throw new AssertionError("OVER unexpected in this context");
+ }
+
+ private void checkRollUpInUsing(SqlIdentifier identifier, SqlNode leftOrRight) {
+ leftOrRight = stripAs(leftOrRight);
+ // if it's not a SqlIdentifier then that's fine, it'll be validated somewhere else.
+ if (leftOrRight instanceof SqlIdentifier) {
+ SqlIdentifier from = (SqlIdentifier) leftOrRight;
+ Table table = findTable(catalogReader.getRootSchema(), Util.last(from.names),
+ catalogReader.nameMatcher().isCaseSensitive());
+ String name = Util.last(identifier.names);
+
+ if (table != null && table.isRolledUp(name)) {
+ throw newValidationError(identifier, RESOURCE.rolledUpNotAllowed(name, "USING"));
+ }
+ }
+ }
+
+ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
+ SqlNode left = join.getLeft();
+ SqlNode right = join.getRight();
+ SqlNode condition = join.getCondition();
+ boolean natural = join.isNatural();
+ final JoinType joinType = join.getJoinType();
+ final JoinConditionType conditionType = join.getConditionType();
+ final SqlValidatorScope joinScope = scopes.get(join);
+ validateFrom(left, unknownType, joinScope);
+ validateFrom(right, unknownType, joinScope);
+
+ // Validate condition.
+ switch (conditionType) {
+ case NONE:
+ Preconditions.checkArgument(condition == null);
+ break;
+ case ON:
+ Preconditions.checkArgument(condition != null);
+ SqlNode expandedCondition = expand(condition, joinScope);
+ join.setOperand(5, expandedCondition);
+ condition = join.getCondition();
+ validateWhereOrOn(joinScope, condition, "ON");
+ checkRollUp(null, join, condition, joinScope, "ON");
+ break;
+ case USING:
+ SqlNodeList list = (SqlNodeList) condition;
+
+ // Parser ensures that using clause is not empty.
+ Preconditions.checkArgument(list.size() > 0, "Empty USING clause");
+ for (SqlNode node : list) {
+ SqlIdentifier id = (SqlIdentifier) node;
+ final RelDataType leftColType = validateUsingCol(id, left);
+ final RelDataType rightColType = validateUsingCol(id, right);
+ if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
+ throw newValidationError(id,
+ RESOURCE.naturalOrUsingColumnNotCompatible(id.getSimple(),
+ leftColType.toString(), rightColType.toString()));
+ }
+ checkRollUpInUsing(id, left);
+ checkRollUpInUsing(id, right);
+ }
+ break;
+ default:
+ throw Util.unexpected(conditionType);
+ }
+
+ // Validate NATURAL.
+ if (natural) {
+ if (condition != null) {
+ throw newValidationError(condition,
+ RESOURCE.naturalDisallowsOnOrUsing());
+ }
+
+ // Join on fields that occur exactly once on each side. Ignore
+ // fields that occur more than once on either side.
+ final RelDataType leftRowType = getNamespace(left).getRowType();
+ final RelDataType rightRowType = getNamespace(right).getRowType();
+ final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+ List<String> naturalColumnNames =
+ SqlValidatorUtil.deriveNaturalJoinColumnList(nameMatcher,
+ leftRowType, rightRowType);
+
+ // Check compatibility of the chosen columns.
+ for (String name : naturalColumnNames) {
+ final RelDataType leftColType =
+ nameMatcher.field(leftRowType, name).getType();
+ final RelDataType rightColType =
+ nameMatcher.field(rightRowType, name).getType();
+ if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
+ throw newValidationError(join,
+ RESOURCE.naturalOrUsingColumnNotCompatible(name,
+ leftColType.toString(), rightColType.toString()));
+ }
+ }
+ }
+
+ // Which join types require/allow a ON/USING condition, or allow
+ // a NATURAL keyword?
+ switch (joinType) {
+ case LEFT_SEMI_JOIN:
+ if (!conformance.isLiberal()) {
+ throw newValidationError(join.getJoinTypeNode(),
+ RESOURCE.dialectDoesNotSupportFeature("LEFT SEMI JOIN"));
+ }
+ // fall through
+ case INNER:
+ case LEFT:
+ case RIGHT:
+ case FULL:
+ if ((condition == null) && !natural) {
+ throw newValidationError(join, RESOURCE.joinRequiresCondition());
+ }
+ break;
+ case COMMA:
+ case CROSS:
+ if (condition != null) {
+ throw newValidationError(join.getConditionTypeNode(),
+ RESOURCE.crossJoinDisallowsCondition());
+ }
+ if (natural) {
+ throw newValidationError(join.getConditionTypeNode(),
+ RESOURCE.crossJoinDisallowsCondition());
+ }
+ break;
+ default:
+ throw Util.unexpected(joinType);
+ }
+ }
+
+ /**
+ * Throws an error if there is an aggregate or windowed aggregate in the
+ * given clause.
+ *
+ * @param aggFinder Finder for the particular kind(s) of aggregate function
+ * @param node Parse tree
+ * @param clause Name of clause: "WHERE", "GROUP BY", "ON"
+ */
+ private void validateNoAggs(AggFinder aggFinder, SqlNode node,
+ String clause) {
+ final SqlCall agg = aggFinder.findAgg(node);
+ if (agg == null) {
+ return;
+ }
+ final SqlOperator op = agg.getOperator();
+ if (op == SqlStdOperatorTable.OVER) {
+ throw newValidationError(agg,
+ RESOURCE.windowedAggregateIllegalInClause(clause));
+ } else if (op.isGroup() || op.isGroupAuxiliary()) {
+ throw newValidationError(agg,
+ RESOURCE.groupFunctionMustAppearInGroupByClause(op.getName()));
+ } else {
+ throw newValidationError(agg,
+ RESOURCE.aggregateIllegalInClause(clause));
+ }
+ }
+
+ private RelDataType validateUsingCol(SqlIdentifier id, SqlNode leftOrRight) {
+ if (id.names.size() == 1) {
+ String name = id.names.get(0);
+ final SqlValidatorNamespace namespace = getNamespace(leftOrRight);
+ final RelDataType rowType = namespace.getRowType();
+ final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+ final RelDataTypeField field = nameMatcher.field(rowType, name);
+ if (field != null) {
+ if (nameMatcher.frequency(rowType.getFieldNames(), name) > 1) {
+ throw newValidationError(id,
+ RESOURCE.columnInUsingNotUnique(id.toString()));
+ }
+ return field.getType();
+ }
+ }
+ throw newValidationError(id, RESOURCE.columnNotFound(id.toString()));
+ }
+
+ /**
+ * Validates a SELECT statement.
+ *
+ * @param select Select statement
+ * @param targetRowType Desired row type, must not be null, may be the data
+ * type 'unknown'.
+ */
+ protected void validateSelect(
+ SqlSelect select,
+ RelDataType targetRowType) {
+ assert targetRowType != null;
+ // Namespace is either a select namespace or a wrapper around one.
+ final SelectNamespace ns =
+ getNamespace(select).unwrap(SelectNamespace.class);
+
+ // Its rowtype is null, meaning it hasn't been validated yet.
+ // This is important, because we need to take the targetRowType into
+ // account.
+ assert ns.rowType == null;
+
+ if (select.isDistinct()) {
+ validateFeature(RESOURCE.sQLFeature_E051_01(),
+ select.getModifierNode(SqlSelectKeyword.DISTINCT)
+ .getParserPosition());
+ }
+
+ final SqlNodeList selectItems = select.getSelectList();
+ RelDataType fromType = unknownType;
+ if (selectItems.size() == 1) {
+ final SqlNode selectItem = selectItems.get(0);
+ if (selectItem instanceof SqlIdentifier) {
+ SqlIdentifier id = (SqlIdentifier) selectItem;
+ if (id.isStar() && (id.names.size() == 1)) {
+ // Special case: for INSERT ... VALUES(?,?), the SQL
+ // standard says we're supposed to propagate the target
+ // types down. So iff the select list is an unqualified
+ // star (as it will be after an INSERT ... VALUES has been
+ // expanded), then propagate.
+ fromType = targetRowType;
+ }
+ }
+ }
+
+ // Make sure that items in FROM clause have distinct aliases.
+ final SelectScope fromScope = (SelectScope) getFromScope(select);
+ List<String> names = fromScope.getChildNames();
+ if (!catalogReader.nameMatcher().isCaseSensitive()) {
+ names = Lists.transform(names, s -> s.toUpperCase(Locale.ROOT));
+ }
+ final int duplicateAliasOrdinal = Util.firstDuplicate(names);
+ if (duplicateAliasOrdinal >= 0) {
+ final ScopeChild child =
+ fromScope.children.get(duplicateAliasOrdinal);
+ throw newValidationError(child.namespace.getEnclosingNode(),
+ RESOURCE.fromAliasDuplicate(child.name));
+ }
+
+ if (select.getFrom() == null) {
+ if (conformance.isFromRequired()) {
+ throw newValidationError(select, RESOURCE.selectMissingFrom());
+ }
+ } else {
+ validateFrom(select.getFrom(), fromType, fromScope);
+ }
+
+ validateWhereClause(select);
+ validateGroupClause(select);
+ validateHavingClause(select);
+ validateWindowClause(select);
+ handleOffsetFetch(select.getOffset(), select.getFetch());
+
+ // Validate the SELECT clause late, because a select item might
+ // depend on the GROUP BY list, or the window function might reference
+ // window name in the WINDOW clause etc.
+ final RelDataType rowType =
+ validateSelectList(selectItems, select, targetRowType);
+ ns.setType(rowType);
+
+ // Validate ORDER BY after we have set ns.rowType because in some
+ // dialects you can refer to columns of the select list, e.g.
+ // "SELECT empno AS x FROM emp ORDER BY x"
+ validateOrderList(select);
+
+ if (shouldCheckForRollUp(select.getFrom())) {
+ checkRollUpInSelectList(select);
+ checkRollUp(null, select, select.getWhere(), getWhereScope(select));
+ checkRollUp(null, select, select.getHaving(), getHavingScope(select));
+ checkRollUpInWindowDecl(select);
+ checkRollUpInGroupBy(select);
+ checkRollUpInOrderBy(select);
+ }
+ }
+
+ private void checkRollUpInSelectList(SqlSelect select) {
+ SqlValidatorScope scope = getSelectScope(select);
+ for (SqlNode item : select.getSelectList()) {
+ checkRollUp(null, select, item, scope);
+ }
+ }
+
+ private void checkRollUpInGroupBy(SqlSelect select) {
+ SqlNodeList group = select.getGroup();
+ if (group != null) {
+ for (SqlNode node : group) {
+ checkRollUp(null, select, node, getGroupScope(select), "GROUP BY");
+ }
+ }
+ }
+
+ private void checkRollUpInOrderBy(SqlSelect select) {
+ SqlNodeList orderList = select.getOrderList();
+ if (orderList != null) {
+ for (SqlNode node : orderList) {
+ checkRollUp(null, select, node, getOrderScope(select), "ORDER BY");
+ }
+ }
+ }
+
+ private void checkRollUpInWindow(SqlWindow window, SqlValidatorScope scope) {
+ 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");
+ }
+ }
+ }
+
+ private void checkRollUpInWindowDecl(SqlSelect select) {
+ for (SqlNode decl : select.getWindowList()) {
+ checkRollUpInWindow((SqlWindow) decl, getSelectScope(select));
+ }
+ }
+
+ private SqlNode stripDot(SqlNode node) {
+ if (node != null && node.getKind() == SqlKind.DOT) {
+ return stripDot(((SqlCall) node).operand(0));
+ }
+ return node;
+ }
+
+ private void checkRollUp(SqlNode grandParent, SqlNode parent,
+ SqlNode current, SqlValidatorScope scope, String optionalClause) {
+ current = stripAs(current);
+ if (current instanceof SqlCall && !(current instanceof SqlSelect)) {
+ // Validate OVER separately
+ checkRollUpInWindow(getWindowInOver(current), scope);
+ current = stripOver(current);
+
+ List<SqlNode> children = ((SqlCall) 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));
+ }
+ }
+ }
+ }
+
+ private void checkRollUp(SqlNode grandParent, SqlNode parent,
+ SqlNode current, SqlValidatorScope scope) {
+ checkRollUp(grandParent, parent, current, scope, null);
+ }
+
+ private SqlWindow getWindowInOver(SqlNode over) {
+ 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;
+ }
+
+ private static SqlNode stripOver(SqlNode node) {
+ switch (node.getKind()) {
+ case OVER:
+ return ((SqlCall) node).getOperandList().get(0);
+ default:
+ return node;
+ }
+ }
+
+ private Pair<String, String> findTableColumnPair(SqlIdentifier identifier,
+ SqlValidatorScope scope) {
+ SqlCall call = SqlUtil.makeCall(getOperatorTable(), 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));
+ }
+
+ // Returns true iff the given column is valid inside the given aggCall.
+ private boolean isRolledUpColumnAllowedInAgg(SqlIdentifier identifier, SqlValidatorScope scope,
+ SqlCall aggCall, SqlNode parent) {
+ Pair<String, String> pair = findTableColumnPair(identifier, scope);
+
+ if (pair == null) {
+ return true;
+ }
+
+ String tableAlias = pair.left;
+ String columnName = pair.right;
+
+ Table table = findTable(tableAlias);
+ if (table != null) {
+ return table.rolledUpColumnValidInsideAgg(columnName, aggCall, parent,
+ catalogReader.getConfig());
+ }
+ return true;
+ }
+
+
+ // Returns true iff the given column is actually rolled up.
+ private boolean isRolledUpColumn(SqlIdentifier identifier, SqlValidatorScope scope) {
+ Pair<String, String> pair = findTableColumnPair(identifier, scope);
+
+ if (pair == null) {
+ return false;
+ }
+
+ String tableAlias = pair.left;
+ String columnName = pair.right;
+
+ Table table = findTable(tableAlias);
+ if (table != null) {
+ return table.isRolledUp(columnName);
+ }
+ return false;
+ }
+
+ private Table findTable(CalciteSchema schema, String tableName, boolean caseSensitive) {
+ CalciteSchema.TableEntry entry = schema.getTable(tableName, caseSensitive);
+ if (entry != null) {
+ return entry.getTable();
+ }
+
+ // Check sub schemas
+ for (CalciteSchema subSchema : schema.getSubSchemaMap().values()) {
+ Table table = findTable(subSchema, tableName, caseSensitive);
+ if (table != null) {
+ return table;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Given a table alias, find the corresponding {@link Table} associated with it
+ * */
+ private Table findTable(String alias) {
+ List<String> names = null;
+ if (tableScope == null) {
+ // no tables to find
+ return null;
+ }
+
+ for (ScopeChild child : tableScope.children) {
+ if (catalogReader.nameMatcher().matches(child.name, alias)) {
+ names = ((SqlIdentifier) child.namespace.getNode()).names;
+ break;
+ }
+ }
+ if (names == null || names.size() == 0) {
+ return null;
+ } else if (names.size() == 1) {
+ return findTable(catalogReader.getRootSchema(), names.get(0),
+ catalogReader.nameMatcher().isCaseSensitive());
+ }
+
+ CalciteSchema.TableEntry entry =
+ SqlValidatorUtil.getTableEntry(catalogReader, names);
+
+ return entry == null ? null : entry.getTable();
+ }
+
+ private boolean shouldCheckForRollUp(SqlNode from) {
+ if (from != null) {
+ SqlKind kind = stripAs(from).getKind();
+ return kind != SqlKind.VALUES && kind != SqlKind.SELECT;
+ }
+ return false;
+ }
+
+ /** Validates that a query can deliver the modality it promises. Only called
+ * on the top-most SELECT or set operator in the tree. */
+ private void validateModality(SqlNode query) {
+ final SqlModality modality = deduceModality(query);
+ if (query instanceof SqlSelect) {
+ final SqlSelect select = (SqlSelect) query;
+ validateModality(select, modality, true);
+ } else if (query.getKind() == SqlKind.VALUES) {
+ switch (modality) {
+ case STREAM:
+ throw newValidationError(query, Static.RESOURCE.cannotStreamValues());
+ }
+ } else {
+ assert query.isA(SqlKind.SET_QUERY);
+ final SqlCall call = (SqlCall) query;
+ for (SqlNode operand : call.getOperandList()) {
+ if (deduceModality(operand) != modality) {
+ throw newValidationError(operand,
+ Static.RESOURCE.streamSetOpInconsistentInputs());
+ }
+ validateModality(operand);
+ }
+ }
+ }
+
+ /** Return the intended modality of a SELECT or set-op. */
+ private SqlModality deduceModality(SqlNode query) {
+ 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));
+ }
+ }
+
+ public boolean validateModality(SqlSelect select, SqlModality modality,
+ boolean fail) {
+ final SelectScope scope = getRawSelectScope(select);
+
+ switch (modality) {
+ case STREAM:
+ if (scope.children.size() == 1) {
+ for (ScopeChild child : scope.children) {
+ if (!child.namespace.supportsModality(modality)) {
+ if (fail) {
+ throw newValidationError(child.namespace.getNode(),
+ Static.RESOURCE.cannotConvertToStream(child.name));
+ } else {
+ return false;
+ }
+ }
+ }
+ } else {
+ int supportsModalityCount = 0;
+ for (ScopeChild child : scope.children) {
+ if (child.namespace.supportsModality(modality)) {
+ ++supportsModalityCount;
+ }
+ }
+
+ if (supportsModalityCount == 0) {
+ if (fail) {
+ String inputs = String.join(", ", scope.getChildNames());
+ throw newValidationError(select,
+ Static.RESOURCE.cannotStreamResultsForNonStreamingInputs(inputs));
+ } else {
+ return false;
+ }
+ }
+ }
+ break;
+ default:
+ for (ScopeChild child : scope.children) {
+ if (!child.namespace.supportsModality(modality)) {
+ if (fail) {
+ throw newValidationError(child.namespace.getNode(),
+ Static.RESOURCE.cannotConvertToRelation(child.name));
+ } else {
+ return false;
+ }
+ }
+ }
+ }
+
+ // Make sure that aggregation is possible.
+ final SqlNode aggregateNode = getAggregate(select);
+ if (aggregateNode != null) {
+ switch (modality) {
+ case STREAM:
+ SqlNodeList groupList = select.getGroup();
+ if (groupList == null
+ || !SqlValidatorUtil.containsMonotonic(scope, groupList)) {
+ if (fail) {
+ throw newValidationError(aggregateNode,
+ Static.RESOURCE.streamMustGroupByMonotonic());
+ } else {
+ return false;
+ }
+ }
+ }
+ }
+
+ // Make sure that ORDER BY is possible.
+ final SqlNodeList orderList = select.getOrderList();
+ if (orderList != null && orderList.size() > 0) {
+ switch (modality) {
+ case STREAM:
+ if (!hasSortedPrefix(scope, orderList)) {
+ if (fail) {
+ throw newValidationError(orderList.get(0),
+ Static.RESOURCE.streamMustOrderByMonotonic());
+ } else {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ /** Returns whether the prefix is sorted. */
+ private boolean hasSortedPrefix(SelectScope scope, SqlNodeList orderList) {
+ return isSortCompatible(scope, orderList.get(0), false);
+ }
+
+ private boolean isSortCompatible(SelectScope scope, SqlNode node,
+ boolean descending) {
+ 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;
+ }
+ }
+
+ protected void validateWindowClause(SqlSelect select) {
+ final SqlNodeList windowList = select.getWindowList();
+ @SuppressWarnings("unchecked") final List<SqlWindow> windows =
+ (List) windowList.getList();
+ if (windows.isEmpty()) {
+ return;
+ }
+
+ final SelectScope windowScope = (SelectScope) getFromScope(select);
+ assert windowScope != null;
+
+ // 1. ensure window names are simple
+ // 2. ensure they are unique within this scope
+ for (SqlWindow window : windows) {
+ SqlIdentifier declName = window.getDeclName();
+ if (!declName.isSimple()) {
+ throw newValidationError(declName, RESOURCE.windowNameMustBeSimple());
+ }
+
+ if (windowScope.existingWindowName(declName.toString())) {
+ throw newValidationError(declName, RESOURCE.duplicateWindowName());
+ } else {
+ windowScope.addWindowName(declName.toString());
+ }
+ }
+
+ // 7.10 rule 2
+ // Check for pairs of windows which are equivalent.
+ for (int i = 0; i < windows.size(); i++) {
+ SqlNode window1 = windows.get(i);
+ for (int j = i + 1; j < windows.size(); j++) {
+ SqlNode window2 = windows.get(j);
+ if (window1.equalsDeep(window2, Litmus.IGNORE)) {
+ throw newValidationError(window2, RESOURCE.dupWindowSpec());
+ }
+ }
+ }
+
+ for (SqlWindow window : windows) {
+ final SqlNodeList expandedOrderList =
+ (SqlNodeList) expand(window.getOrderList(), windowScope);
+ window.setOrderList(expandedOrderList);
+ expandedOrderList.validate(this, windowScope);
+
+ final SqlNodeList expandedPartitionList =
+ (SqlNodeList) expand(window.getPartitionList(), windowScope);
+ window.setPartitionList(expandedPartitionList);
+ expandedPartitionList.validate(this, windowScope);
+ }
+
+ // Hand off to validate window spec components
+ windowList.validate(this, windowScope);
+ }
+
+ public void validateWith(SqlWith with, SqlValidatorScope scope) {
+ final SqlValidatorNamespace namespace = getNamespace(with);
+ validateNamespace(namespace, unknownType);
+ }
+
+ public void validateWithItem(SqlWithItem withItem) {
+ if (withItem.columnList != null) {
+ final RelDataType rowType = getValidatedNodeType(withItem.query);
+ final int fieldCount = rowType.getFieldCount();
+ if (withItem.columnList.size() != fieldCount) {
+ throw newValidationError(withItem.columnList,
+ RESOURCE.columnCountMismatch());
+ }
+ SqlValidatorUtil.checkIdentifierListForDuplicates(
+ withItem.columnList.getList(), validationErrorFunction);
+ } else {
+ // Luckily, field names have not been make unique yet.
+ final List<String> fieldNames =
+ getValidatedNodeType(withItem.query).getFieldNames();
+ final int i = Util.firstDuplicate(fieldNames);
+ if (i >= 0) {
+ throw newValidationError(withItem.query,
+ RESOURCE.duplicateColumnAndNoColumnList(fieldNames.get(i)));
+ }
+ }
+ }
+
+ public void validateSequenceValue(SqlValidatorScope scope, SqlIdentifier id) {
+ // Resolve identifier as a table.
+ final SqlValidatorScope.ResolvedImpl resolved =
+ new SqlValidatorScope.ResolvedImpl();
+ scope.resolveTable(id.names, catalogReader.nameMatcher(),
+ SqlValidatorScope.Path.EMPTY, resolved);
+ if (resolved.count() != 1) {
+ throw newValidationError(id, RESOURCE.tableNameNotFound(id.toString()));
+ }
+ // We've found a table. But is it a sequence?
+ final SqlValidatorNamespace ns = resolved.only().namespace;
+ if (ns instanceof TableNamespace) {
+ final Table table = ns.getTable().unwrap(Table.class);
+ switch (table.getJdbcTableType()) {
+ case SEQUENCE:
+ case TEMPORARY_SEQUENCE:
+ return;
+ }
+ }
+ throw newValidationError(id, RESOURCE.notASequence(id.toString()));
+ }
+
+ public SqlValidatorScope getWithScope(SqlNode withItem) {
+ assert withItem.getKind() == SqlKind.WITH_ITEM;
+ return scopes.get(withItem);
+ }
+
+ /**
+ * Validates the ORDER BY clause of a SELECT statement.
+ *
+ * @param select Select statement
+ */
+ protected void validateOrderList(SqlSelect select) {
+ // ORDER BY is validated in a scope where aliases in the SELECT clause
+ // are visible. For example, "SELECT empno AS x FROM emp ORDER BY x"
+ // is valid.
+ SqlNodeList orderList = select.getOrderList();
+ if (orderList == null) {
+ return;
+ }
+ if (!shouldAllowIntermediateOrderBy()) {
+ if (!cursorSet.contains(select)) {
+ throw newValidationError(select, RESOURCE.invalidOrderByPos());
+ }
+ }
+ final SqlValidatorScope orderScope = getOrderScope(select);
+ Objects.requireNonNull(orderScope);
+
+ List<SqlNode> expandList = new ArrayList<>();
+ for (SqlNode orderItem : orderList) {
+ SqlNode expandedOrderItem = expand(orderItem, orderScope);
+ expandList.add(expandedOrderItem);
+ }
+
+ SqlNodeList expandedOrderList = new SqlNodeList(
+ expandList,
+ orderList.getParserPosition());
+ select.setOrderBy(expandedOrderList);
+
+ for (SqlNode orderItem : expandedOrderList) {
+ validateOrderItem(select, orderItem);
+ }
+ }
+
+ /**
+ * Validates an item in the GROUP BY clause of a SELECT statement.
+ *
+ * @param select Select statement
+ * @param groupByItem GROUP BY clause item
+ */
+ private void validateGroupByItem(SqlSelect select, SqlNode groupByItem) {
+ final SqlValidatorScope groupByScope = getGroupScope(select);
+ groupByScope.validateExpr(groupByItem);
+ }
+
+ /**
+ * Validates an item in the ORDER BY clause of a SELECT statement.
+ *
+ * @param select Select statement
+ * @param orderItem ORDER BY clause item
+ */
+ private void validateOrderItem(SqlSelect select, SqlNode orderItem) {
+ switch (orderItem.getKind()) {
+ case DESCENDING:
+ validateFeature(RESOURCE.sQLConformance_OrderByDesc(),
+ orderItem.getParserPosition());
+ validateOrderItem(select,
+ ((SqlCall) orderItem).operand(0));
+ return;
+ }
+
+ final SqlValidatorScope orderScope = getOrderScope(select);
+ validateExpr(orderItem, orderScope);
+ }
+
+ public SqlNode expandOrderExpr(SqlSelect select, SqlNode orderExpr) {
+ 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;
+ }
+
+ /**
+ * Validates the GROUP BY clause of a SELECT statement. This method is
+ * called even if no GROUP BY clause is present.
+ */
+ protected void validateGroupClause(SqlSelect select) {
+ SqlNodeList groupList = select.getGroup();
+ if (groupList == null) {
+ return;
+ }
+ final String clause = "GROUP BY";
+ validateNoAggs(aggOrOverFinder, groupList, clause);
+ final SqlValidatorScope groupScope = getGroupScope(select);
+ inferUnknownTypes(unknownType, groupScope, groupList);
+
+ // expand the expression in group list.
+ List<SqlNode> expandedList = new ArrayList<>();
+ for (SqlNode groupItem : groupList) {
+ SqlNode expandedItem = expandGroupByOrHavingExpr(groupItem, groupScope, select, false);
+ expandedList.add(expandedItem);
+ }
+ groupList = new SqlNodeList(expandedList, groupList.getParserPosition());
+ select.setGroupBy(groupList);
+ for (SqlNode groupItem : expandedList) {
+ validateGroupByItem(select, groupItem);
+ }
+
+ // Nodes in the GROUP BY clause are expressions except if they are calls
+ // to the GROUPING SETS, ROLLUP or CUBE operators; this operators are not
+ // expressions, because they do not have a type.
+ for (SqlNode node : groupList) {
+ switch (node.getKind()) {
+ case GROUPING_SETS:
+ case ROLLUP:
+ case CUBE:
+ node.validate(this, groupScope);
+ break;
+ default:
+ node.validateExpr(this, groupScope);
+ }
+ }
+
+ // Derive the type of each GROUP BY item. We don't need the type, but
+ // it resolves functions, and that is necessary for deducing
+ // monotonicity.
+ final SqlValidatorScope selectScope = getSelectScope(select);
+ AggregatingSelectScope aggregatingScope = null;
+ if (selectScope instanceof AggregatingSelectScope) {
+ aggregatingScope = (AggregatingSelectScope) selectScope;
+ }
+ for (SqlNode groupItem : groupList) {
+ if (groupItem instanceof SqlNodeList
+ && ((SqlNodeList) groupItem).size() == 0) {
+ continue;
+ }
+ validateGroupItem(groupScope, aggregatingScope, groupItem);
+ }
+
+ SqlNode agg = aggFinder.findAgg(groupList);
+ if (agg != null) {
+ throw newValidationError(agg, RESOURCE.aggregateIllegalInClause(clause));
+ }
+ }
+
+ private void validateGroupItem(SqlValidatorScope groupScope,
+ AggregatingSelectScope aggregatingScope,
+ SqlNode groupItem) {
+ switch (groupItem.getKind()) {
+ case GROUPING_SETS:
+ case ROLLUP:
+ case CUBE:
+ validateGroupingSets(groupScope, aggregatingScope, (SqlCall) groupItem);
+ break;
+ default:
+ if (groupItem instanceof SqlNodeList) {
+ break;
+ }
+ final RelDataType type = deriveType(groupScope, groupItem);
+ setValidatedNodeType(groupItem, type);
+ }
+ }
+
+ private void validateGroupingSets(SqlValidatorScope groupScope,
+ AggregatingSelectScope aggregatingScope, SqlCall groupItem) {
+ for (SqlNode node : groupItem.getOperandList()) {
+ validateGroupItem(groupScope, aggregatingScope, node);
+ }
+ }
+
+ protected void validateWhereClause(SqlSelect select) {
+ // validate WHERE clause
+ final SqlNode where = select.getWhere();
+ if (where == null) {
+ return;
+ }
+ final SqlValidatorScope whereScope = getWhereScope(select);
+ final SqlNode expandedWhere = expand(where, whereScope);
+ select.setWhere(expandedWhere);
+ validateWhereOrOn(whereScope, expandedWhere, "WHERE");
+ }
+
+ protected void validateWhereOrOn(
+ SqlValidatorScope scope,
+ SqlNode condition,
+ String clause) {
+ validateNoAggs(aggOrOverOrGroupFinder, condition, clause);
+ inferUnknownTypes(
+ booleanType,
+ scope,
+ condition);
+ condition.validate(this, scope);
+
+ final RelDataType type = deriveType(scope, condition);
+ if (!SqlTypeUtil.inBooleanFamily(type)) {
+ throw newValidationError(condition, RESOURCE.condMustBeBoolean(clause));
+ }
+ }
+
+ protected void validateHavingClause(SqlSelect select) {
+ // HAVING is validated in the scope after groups have been created.
+ // For example, in "SELECT empno FROM emp WHERE empno = 10 GROUP BY
+ // deptno HAVING empno = 10", the reference to 'empno' in the HAVING
+ // clause is illegal.
+ SqlNode having = select.getHaving();
+ if (having == null) {
+ return;
+ }
+ final AggregatingScope havingScope =
+ (AggregatingScope) getSelectScope(select);
+ if (getConformance().isHavingAlias()) {
+ SqlNode newExpr = expandGroupByOrHavingExpr(having, havingScope, select, true);
+ if (having != newExpr) {
+ having = newExpr;
+ select.setHaving(newExpr);
+ }
+ }
+ havingScope.checkAggregateExpr(having, true);
+ inferUnknownTypes(
+ booleanType,
+ havingScope,
+ having);
+ having.validate(this, havingScope);
+ final RelDataType type = deriveType(havingScope, having);
+ if (!SqlTypeUtil.inBooleanFamily(type)) {
+ throw newValidationError(having, RESOURCE.havingMustBeBoolean());
+ }
+ }
+
+ protected RelDataType validateSelectList(
+ final SqlNodeList selectItems,
+ SqlSelect select,
+ RelDataType targetRowType) {
+ // First pass, ensure that aliases are unique. "*" and "TABLE.*" items
+ // are ignored.
+
+ // Validate SELECT list. Expand terms of the form "*" or "TABLE.*".
+ final SqlValidatorScope selectScope = getSelectScope(select);
+ final List<SqlNode> expandedSelectItems = new ArrayList<>();
+ final Set<String> aliases = new HashSet<>();
+ final List<Map.Entry<String, RelDataType>> fieldList = new ArrayList<>();
+
+ for (int i = 0; i < selectItems.size(); i++) {
+ SqlNode selectItem = selectItems.get(i);
+ if (selectItem instanceof SqlSelect) {
+ handleScalarSubQuery(
+ select,
+ (SqlSelect) selectItem,
+ expandedSelectItems,
+ aliases,
+ fieldList);
+ } else {
+ expandSelectItem(
+ selectItem,
+ select,
+ targetRowType.isStruct()
+ && targetRowType.getFieldCount() >= i
+ ? targetRowType.getFieldList().get(i).getType()
+ : unknownType,
+ expandedSelectItems,
+ aliases,
+ fieldList,
+ false);
+ }
+ }
+
+ // Create the new select list with expanded items. Pass through
+ // the original parser position so that any overall failures can
+ // still reference the original input text.
+ SqlNodeList newSelectList =
+ new SqlNodeList(
+ expandedSelectItems,
+ selectItems.getParserPosition());
+ if (shouldExpandIdentifiers()) {
+ select.setSelectList(newSelectList);
+ }
+ getRawSelectScope(select).setExpandedSelectList(expandedSelectItems);
+
+ // TODO: when SELECT appears as a value sub-query, should be using
+ // something other than unknownType for targetRowType
+ inferUnknownTypes(targetRowType, selectScope, newSelectList);
+
+ for (SqlNode selectItem : expandedSelectItems) {
+ validateNoAggs(groupFinder, selectItem, "SELECT");
+ validateExpr(selectItem, selectScope);
+ }
+
+ return typeFactory.createStructType(fieldList);
+ }
+
+ /**
+ * Validates an expression.
+ *
+ * @param expr Expression
+ * @param scope Scope in which expression occurs
+ */
+ private void validateExpr(SqlNode expr, SqlValidatorScope scope) {
+ if (expr instanceof SqlCall) {
+ final SqlOperator op = ((SqlCall) expr).getOperator();
+ if (op.isAggregator() && op.requiresOver()) {
+ throw newValidationError(expr,
+ RESOURCE.absentOverClause());
+ }
+ }
+
+ // Call on the expression to validate itself.
+ expr.validateExpr(this, scope);
+
+ // Perform any validation specific to the scope. For example, an
+ // aggregating scope requires that expressions are valid aggregations.
+ scope.validateExpr(expr);
+ }
+
+ /**
+ * 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.
+ *
+ * @param parentSelect base SqlSelect item
+ * @param selectItem child SqlSelect from select list
+ * @param expandedSelectItems Select items after processing
+ * @param aliasList built from user or system values
+ * @param fieldList Built up entries for each select list entry
+ */
+ private void handleScalarSubQuery(
+ SqlSelect parentSelect,
+ SqlSelect selectItem,
+ List<SqlNode> expandedSelectItems,
+ Set<String> aliasList,
+ List<Map.Entry<String, RelDataType>> fieldList) {
+ // 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));
+ }
+
+ /**
+ * Derives a row-type for INSERT and UPDATE operations.
+ *
+ * @param table Target table for INSERT/UPDATE
+ * @param targetColumnList List of target columns, or null if not specified
+ * @param append Whether to append fields to those in <code>
+ * baseRowType</code>
+ * @return Rowtype
+ */
+ protected RelDataType createTargetRowType(
+ SqlValidatorTable table,
+ SqlNodeList targetColumnList,
+ boolean append) {
+ 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);
+ }
+
+ public void validateInsert(SqlInsert insert) {
+ final SqlValidatorNamespace targetNamespace = getNamespace(insert);
+ validateNamespace(targetNamespace, unknownType);
+ final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
+ targetNamespace, catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
+ final SqlValidatorTable table = relOptTable == null
+ ? targetNamespace.getTable()
+ : relOptTable.unwrap(SqlValidatorTable.class);
+
+ // INSERT has an optional column name list. If present then
+ // reduce the rowtype to the columns specified. If not present
+ // then the entire target rowtype is used.
+ final RelDataType targetRowType =
+ createTargetRowType(
+ table,
+ insert.getTargetColumnList(),
+ false);
+
+ final SqlNode source = insert.getSource();
+ if (source instanceof SqlSelect) {
+ final SqlSelect sqlSelect = (SqlSelect) source;
+ validateSelect(sqlSelect, targetRowType);
+ } else {
+ final SqlValidatorScope scope = scopes.get(source);
+ validateQuery(source, scope, targetRowType);
+ }
+
+ // REVIEW jvs 4-Dec-2008: In FRG-365, this namespace row type is
+ // discarding the type inferred by inferUnknownTypes (which was invoked
+ // from validateSelect above). It would be better if that information
+ // were used here so that we never saw any untyped nulls during
+ // checkTypeAssignment.
+ final RelDataType sourceRowType = getNamespace(source).getRowType();
+ final RelDataType logicalTargetRowType =
+ getLogicalTargetRowType(targetRowType, insert);
+ setValidatedNodeType(insert, logicalTargetRowType);
+ final RelDataType logicalSourceRowType =
+ getLogicalSourceRowType(sourceRowType, insert);
+
+ checkFieldCount(insert.getTargetTable(), table, source,
+ logicalSourceRowType, logicalTargetRowType);
+
+ checkTypeAssignment(logicalSourceRowType, logicalTargetRowType, insert);
+
+ checkConstraint(table, source, logicalTargetRowType);
+
+ validateAccess(insert.getTargetTable(), table, SqlAccessEnum.INSERT);
+ }
+
+ /**
+ * Validates insert values against the constraint of a modifiable view.
+ *
+ * @param validatorTable Table that may wrap a ModifiableViewTable
+ * @param source The values being inserted
+ * @param targetRowType The target type for the view
+ */
+ private void checkConstraint(
+ SqlValidatorTable validatorTable,
+ SqlNode source,
+ RelDataType targetRowType) {
+ 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);
+ }
+ }
+ }
+ }
+
+ /**
+ * Validates updates against the constraint of a modifiable view.
+ *
+ * @param validatorTable A {@link SqlValidatorTable} that may wrap a
+ * ModifiableViewTable
+ * @param update The UPDATE parse tree node
+ * @param targetRowType The target type
+ */
+ private void checkConstraint(
+ SqlValidatorTable validatorTable,
+ SqlUpdate update,
+ RelDataType targetRowType) {
+ 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);
+ }
+ }
+ }
+ }
+
+ private void checkFieldCount(SqlNode node, SqlValidatorTable table,
+ SqlNode source, RelDataType logicalSourceRowType,
+ RelDataType logicalTargetRowType) {
+ final int sourceFieldCount = logicalSourceRowType.getFieldCount();
+ final int targetFieldCount = logicalTargetRowType.getFieldCount();
+ if (sourceFieldCount != targetFieldCount) {
+ throw newValidationError(node,
+ RESOURCE.unmatchInsertColumn(targetFieldCount, sourceFieldCount));
+ }
+ // Ensure that non-nullable fields are targeted.
+ final InitializerContext rexBuilder =
+ new InitializerContext() {
+ public RexBuilder getRexBuilder() {
+ return new RexBuilder(typeFactory);
+ }
+
+ public RexNode convertExpression(SqlNode e) {
+ throw new UnsupportedOperationException();
+ }
+ };
+ final List<ColumnStrategy> strategies =
+ table.unwrap(RelOptTable.class).getColumnStrategies();
+ for (final RelDataTypeField field : table.getRowType().getFieldList()) {
+ final RelDataTypeField targetField =
+ logicalTargetRowType.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()));
+ }
+ }
+ }
+ }
+
+ /** Returns whether a query uses {@code DEFAULT} to populate a given
+ * column. */
+ private boolean isValuesWithDefault(SqlNode source, int column) {
+ switch (source.getKind()) {
+ case VALUES:
+ for (SqlNode operand : ((SqlCall) source).getOperandList()) {
+ if (!isRowWithDefault(operand, column)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+
+ private boolean isRowWithDefault(SqlNode operand, int column) {
+ switch (operand.getKind()) {
+ case ROW:
+ final SqlCall row = (SqlCall) operand;
+ return row.getOperandList().size() >= column
+ && row.getOperandList().get(column).getKind() == SqlKind.DEFAULT;
+ }
+ return false;
+ }
+
+ protected RelDataType getLogicalTargetRowType(
+ RelDataType targetRowType,
+ SqlInsert insert) {
+ if (insert.getTargetColumnList() == null
+ && conformance.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;
+ }
+ }
+
+ protected RelDataType getLogicalSourceRowType(
+ RelDataType sourceRowType,
+ SqlInsert insert) {
+ return sourceRowType;
+ }
+
+ protected void checkTypeAssignment(
+ RelDataType sourceRowType,
+ RelDataType targetRowType,
+ final SqlNode query) {
+ // NOTE jvs 23-Feb-2006: subclasses may allow for extra targets
+ // representing system-maintained columns, so stop after all sources
+ // matched
+ 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)) {
+ // FRG-255: account for UPDATE rewrite; there's
+ // probably a better way to do this.
+ int iAdjusted = i;
+ if (query instanceof SqlUpdate) {
+ int nUpdateColumns =
+ ((SqlUpdate) query).getTargetColumnList().size();
+ assert sourceFields.size() >= nUpdateColumns;
+ iAdjusted -= sourceFields.size() - nUpdateColumns;
+ }
+ SqlNode node = getNthExpr(query, iAdjusted, sourceCount);
+ 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));
+ }
+ }
+ }
+
+ /**
+ * Locates the n'th expression in an INSERT or UPDATE query.
+ *
+ * @param query Query
+ * @param ordinal Ordinal of expression
+ * @param sourceCount Number of expressions
+ * @return Ordinal'th expression, never null
+ */
+ private SqlNode getNthExpr(SqlNode query, int ordinal, int sourceCount) {
+ 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.getTargetColumnList() != null) {
+ return update.getTargetColumnList().get(ordinal);
+ } else 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
+ }
+ }
+
+ public void validateDelete(SqlDelete call) {
+ final SqlSelect sqlSelect = call.getSourceSelect();
+ validateSelect(sqlSelect, unknownType);
+
+ final SqlValidatorNamespace targetNamespace = getNamespace(call);
+ validateNamespace(targetNamespace, unknownType);
+ final SqlValidatorTable table = targetNamespace.getTable();
+
+ validateAccess(call.getTargetTable(), table, SqlAccessEnum.DELETE);
+ }
+
+ public void validateUpdate(SqlUpdate call) {
+ final SqlValidatorNamespace targetNamespace = getNamespace(call);
+ validateNamespace(targetNamespace, unknownType);
+ final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
+ targetNamespace, catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
+ final SqlValidatorTable table = relOptTable == null
+ ? targetNamespace.getTable()
+ : relOptTable.unwrap(SqlValidatorTable.class);
+
+ final RelDataType targetRowType =
+ createTargetRowType(
+ table,
+ call.getTargetColumnList(),
+ true);
+
+ final SqlSelect select = call.getSourceSelect();
+ validateSelect(select, targetRowType);
+
+ final RelDataType sourceRowType = getNamespace(call).getRowType();
+ checkTypeAssignment(sourceRowType, targetRowType, call);
+
+ checkConstraint(table, call, targetRowType);
+
+ validateAccess(call.getTargetTable(), table, SqlAccessEnum.UPDATE);
+ }
+
+ public void validateMerge(SqlMerge call) {
+ SqlSelect sqlSelect = call.getSourceSelect();
+ // REVIEW zfong 5/25/06 - Does an actual type have to be passed into
+ // validateSelect()?
+
+ // REVIEW jvs 6-June-2006: In general, passing unknownType like
+ // this means we won't be able to correctly infer the types
+ // for dynamic parameter markers (SET x = ?). But
+ // maybe validateUpdate and validateInsert below will do
+ // the job?
+
+ // REVIEW ksecretan 15-July-2011: They didn't get a chance to
+ // since validateSelect() would bail.
+ // Let's use the update/insert targetRowType when available.
+ IdentifierNamespace targetNamespace =
+ (IdentifierNamespace) getNamespace(call.getTargetTable());
+ validateNamespace(targetNamespace, unknownType);
+
+ SqlValidatorTable table = targetNamespace.getTable();
+ validateAccess(call.getTargetTable(), table, SqlAccessEnum.UPDATE);
+
+ RelDataType targetRowType = unknownType;
+
+ if (call.getUpdateCall() != null) {
+ targetRowType = createTargetRowType(
+ table,
+ call.getUpdateCall().getTargetColumnList(),
+ true);
+ }
+ if (call.getInsertCall() != null) {
+ targetRowType = createTargetRowType(
+ table,
+ call.getInsertCall().getTargetColumnList(),
+ false);
+ }
+
+ validateSelect(sqlSelect, targetRowType);
+
+ if (call.getUpdateCall() != null) {
+ validateUpdate(call.getUpdateCall());
+ }
+ if (call.getInsertCall() != null) {
+ validateInsert(call.getInsertCall());
+ }
+ }
+
+ /**
+ * Validates access to a table.
+ *
+ * @param table Table
+ * @param requiredAccess Access requested on table
+ */
+ private void validateAccess(
+ SqlNode node,
+ SqlValidatorTable table,
+ SqlAccessEnum requiredAccess) {
+ if (table != null) {
+ SqlAccessType access = table.getAllowedAccess();
+ if (!access.allowsAccess(requiredAccess)) {
+ throw newValidationError(node,
+ RESOURCE.accessNotAllowed(requiredAccess.name(),
+ table.getQualifiedName().toString()));
+ }
+ }
+ }
+
+ /**
+ * Validates a VALUES clause.
+ *
+ * @param node Values clause
+ * @param targetRowType Row type which expression must conform to
+ * @param scope Scope within which clause occurs
+ */
+ protected void validateValues(
+ SqlCall node,
+ RelDataType targetRowType,
+ final SqlValidatorScope scope) {
+ assert node.getKind() == SqlKind.VALUES;
+
+ final List<SqlNode> operands = node.getOperandList();
+ for (SqlNode operand : operands) {
+ if (!(operand.getKind() == SqlKind.ROW)) {
+ throw Util.needToImplement(
+ "Values function where operands are scalars");
+ }
+
+ SqlCall rowConstructor = (SqlCall) operand;
+ if (conformance.isInsertSubsetColumnsAllowed() && targetRowType.isStruct()
+ && rowConstructor.operandCount() < targetRowType.getFieldCount()) {
+ targetRowType =
+ typeFactory.createStructType(
+ targetRowType.getFieldList()
+ .subList(0, rowConstructor.operandCount()));
+ } else if (targetRowType.isStruct()
+ && rowConstructor.operandCount() != targetRowType.getFieldCount()) {
+ return;
+ }
+
+ inferUnknownTypes(
+ targetRowType,
+ scope,
+ rowConstructor);
+
+ if (targetRowType.isStruct()) {
+ for (Pair<SqlNode, RelDataTypeField> pair
+ : Pair.zip(rowConstructor.getOperandList(),
+ targetRowType.getFieldList())) {
+ if (!pair.right.getType().isNullable()
+ && SqlUtil.isNullLiteral(pair.left, false)) {
+ throw newValidationError(node,
+ RESOURCE.columnNotNullable(pair.right.getName()));
+ }
+ }
+ }
+ }
+
+ for (SqlNode operand : operands) {
+ operand.validate(this, scope);
+ }
+
+ // validate that all row types have the same number of columns
+ // and that expressions in each column are compatible.
+ // A values expression is turned into something that looks like
+ // ROW(type00, type01,...), ROW(type11,...),...
+ final int rowCount = operands.size();
+ if (rowCount >= 2) {
+ SqlCall firstRow = (SqlCall) operands.get(0);
+ final int columnCount = firstRow.operandCount();
+
+ // 1. check that all rows have the same cols length
+ for (SqlNode operand : operands) {
+ SqlCall thisRow = (SqlCall) operand;
+ if (columnCount != thisRow.operandCount()) {
+ throw newValidationError(node,
+ RESOURCE.incompatibleValueType(
+ SqlStdOperatorTable.VALUES.getName()));
+ }
+ }
+
+ // 2. check if types at i:th position in each row are compatible
+ for (int col = 0; col < columnCount; col++) {
+ final int c = col;
+ final RelDataType type =
+ typeFactory.leastRestrictive(
+ new AbstractList<RelDataType>() {
+ public RelDataType get(int row) {
+ SqlCall thisRow = (SqlCall) operands.get(row);
+ return deriveType(scope, thisRow.operand(c));
+ }
+
+ public int size() {
+ return rowCount;
+ }
+ });
+
+ if (null == type) {
+ throw newValidationError(node,
+ RESOURCE.incompatibleValueType(
+ SqlStdOperatorTable.VALUES.getName()));
+ }
+ }
+ }
+ }
+
+ public void validateDataType(SqlDataTypeSpec dataType) {
+ }
+
+ public void validateDynamicParam(SqlDynamicParam dynamicParam) {
+ }
+
+ /**
+ * Throws a validator exception with access to the validator context.
+ * The exception is determined when an instance is created.
+ */
+ private class ValidationError implements Supplier<CalciteContextException> {
+ private final SqlNode sqlNode;
+ private final Resources.ExInst<SqlValidatorException> validatorException;
+
+ ValidationError(SqlNode sqlNode,
+ Resources.ExInst<SqlValidatorException> validatorException) {
+ this.sqlNode = sqlNode;
+ this.validatorException = validatorException;
+ }
+
+ public CalciteContextException get() {
+ return newValidationError(sqlNode, validatorException);
+ }
+ }
+
+ /**
+ * Throws a validator exception with access to the validator context.
+ * The exception is determined when the function is applied.
+ */
+ class ValidationErrorFunction
+ implements Function2<SqlNode, Resources.ExInst<SqlValidatorException>,
+ CalciteContextException> {
+ @Override public CalciteContextException apply(
+ SqlNode v0, Resources.ExInst<SqlValidatorException> v1) {
+ return newValidationError(v0, v1);
+ }
+ }
+
+ public ValidationErrorFunction getValidationErrorFunction() {
+ return validationErrorFunction;
+ }
+
+ public CalciteContextException newValidationError(SqlNode node,
+ Resources.ExInst<SqlValidatorException> e) {
+ assert node != null;
+ final SqlParserPos pos = node.getParserPosition();
+ return SqlUtil.newContextException(pos, e);
+ }
+
+ protected SqlWindow getWindowByName(
+ SqlIdentifier id,
+ SqlValidatorScope scope) {
+ 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;
+ }
+
+ public SqlWindow resolveWindow(
+ SqlNode windowOrRef,
+ SqlValidatorScope scope,
+ boolean populateBounds) {
+ SqlWindow window;
+ if (windowOrRef instanceof SqlIdentifier) {
+ window = getWindowByName((SqlIdentifier) windowOrRef, scope);
+ } else {
+ window = (SqlWindow) windowOrRef;
+ }
+ while (true) {
+ final SqlIdentifier refId = window.getRefName();
+ if (refId == null) {
+ break;
+ }
+ final String refName = refId.getSimple();
+ SqlWindow refWindow = scope.lookupWindow(refName);
+ if (refWindow == null) {
+ throw newValidationError(refId, RESOURCE.windowNotFound(refName));
+ }
+ window = window.overlay(refWindow, this);
+ }
+
+ if (populateBounds) {
+ window.populateBounds();
+ }
+ return window;
+ }
+
+ public SqlNode getOriginal(SqlNode expr) {
+ SqlNode original = originalExprs.get(expr);
+ if (original == null) {
+ original = expr;
+ }
+ return original;
+ }
+
+ public void setOriginal(SqlNode expr, SqlNode original) {
+ // Don't overwrite the original original.
+ if (originalExprs.get(expr) == null) {
+ originalExprs.put(expr, original);
+ }
+ }
+
+ SqlValidatorNamespace lookupFieldNamespace(RelDataType rowType, String name) {
+ final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+ final RelDataTypeField field = nameMatcher.field(rowType, name);
+ return new FieldNamespace(this, field.getType());
+ }
+
+ public void validateWindow(
+ SqlNode windowOrId,
+ SqlValidatorScope scope,
+ SqlCall call) {
+ // Enable nested aggregates with window aggregates (OVER operator)
+ inWindow = true;
+
+ final SqlWindow targetWindow;
+ switch (windowOrId.getKind()) {
+ case IDENTIFIER:
+ // Just verify the window exists in this query. It will validate
+ // when the definition is processed
+ targetWindow = getWindowByName((SqlIdentifier) windowOrId, scope);
+ break;
+ case WINDOW:
+ targetWindow = (SqlWindow) windowOrId;
+ break;
+ default:
+ throw Util.unexpected(windowOrId.getKind());
+ }
+
+ assert targetWindow.getWindowCall() == null;
+ targetWindow.setWindowCall(call);
+ targetWindow.validate(this, scope);
+ targetWindow.setWindowCall(null);
+ call.validate(this, scope);
+
+ validateAggregateParams(call, null, scope);
+
+ // Disable nested aggregates post validation
+ inWindow = false;
+ }
+
+ @Override public void validateMatchRecognize(SqlCall call) {
+ final SqlMatchRecognize matchRecognize = (SqlMatchRecognize) call;
+ final MatchRecognizeScope scope =
+ (MatchRecognizeScope) getMatchRecognizeScope(matchRecognize);
+
+ final MatchRecognizeNamespace ns =
+ getNamespace(call).unwrap(MatchRecognizeNamespace.class);
+ assert ns.rowType == null;
+
+ // rows per match
+ final SqlLiteral rowsPerMatch = matchRecognize.getRowsPerMatch();
+ final boolean allRows = rowsPerMatch != null
+ && rowsPerMatch.getValue()
+ == SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS;
+
+ final RelDataTypeFactory.Builder typeBuilder = typeFactory.builder();
+
+ // parse PARTITION BY column
+ SqlNodeList partitionBy = matchRecognize.getPartitionList();
+ if (partitionBy != null) {
+ for (SqlNode node : partitionBy) {
+ SqlIdentifier identifier = (SqlIdentifier) node;
+ identifier.validate(this, scope);
+ RelDataType type = deriveType(scope, identifier);
+ String name = identifier.names.get(1);
+ typeBuilder.add(name, type);
+ }
+ }
+
+ // parse ORDER BY column
+ SqlNodeList orderBy = matchRecognize.getOrderList();
+ if (orderBy != null) {
+ for (SqlNode node : orderBy) {
+ node.validate(this, scope);
+ SqlIdentifier identifier = null;
+ if (node instanceof SqlBasicCall) {
+ identifier = (SqlIdentifier) ((SqlBasicCall) node).getOperands()[0];
+ } else {
+ identifier = (SqlIdentifier) node;
+ }
+
+ if (allRows) {
+ RelDataType type = deriveType(scope, identifier);
+ String name = identifier.names.get(1);
+ if (!typeBuilder.nameExists(name)) {
+ typeBuilder.add(name, type);
+ }
+ }
+ }
+ }
+
+ if (allRows) {
+ final SqlValidatorNamespace sqlNs =
+ getNamespace(matchRecognize.getTableRef());
+ final RelDataType inputDataType = sqlNs.getRowType();
+ for (RelDataTypeField fs : inputDataType.getFieldList()) {
+ if (!typeBuilder.nameExists(fs.getName())) {
+ typeBuilder.add(fs);
+ }
+ }
+ }
+
+ // retrieve pattern variables used in pattern and subset
+ SqlNode pattern = matchRecognize.getPattern();
+ PatternVarVisitor visitor = new PatternVarVisitor(scope);
+ pattern.accept(visitor);
+
+ SqlLiteral interval = matchRecognize.getInterval();
+ if (interval != null) {
+ interval.validate(this, scope);
+ if (((SqlIntervalLiteral) interval).signum() < 0) {
+ throw newValidationError(interval,
+ RESOURCE.intervalMustBeNonNegative(interval.toValue()));
+ }
+ if (orderBy == null || orderBy.size() == 0) {
+ throw newValidationError(interval,
+ RESOURCE.cannotUseWithinWithoutOrderBy());
+ }
+
+ SqlNode firstOrderByColumn = orderBy.getList().get(0);
+ SqlIdentifier identifier;
+ if (firstOrderByColumn instanceof SqlBasicCall) {
+ identifier = (SqlIdentifier) ((SqlBasicCall) firstOrderByColumn).getOperands()[0];
+ } else {
+ identifier = (SqlIdentifier) firstOrderByColumn;
+ }
+ RelDataType firstOrderByColumnType = deriveType(scope, identifier);
+ if (firstOrderByColumnType.getSqlTypeName() != SqlTypeName.TIMESTAMP) {
+ throw newValidationError(interval,
+ RESOURCE.firstColumnOfOrderByMustBeTimestamp());
+ }
+
+ SqlNode expand = expand(interval, scope);
+ RelDataType type = deriveType(scope, expand);
+ setValidatedNodeType(interval, type);
+ }
+
+ validateDefinitions(matchRecognize, scope);
+
+ SqlNodeList subsets = matchRecognize.getSubsetList();
+ if (subsets != null && subsets.size() > 0) {
+ for (SqlNode node : subsets) {
+ List<SqlNode> operands = ((SqlCall) node).getOperandList();
+ String leftString = ((SqlIdentifier) operands.get(0)).getSimple();
+ if (scope.getPatternVars().contains(leftString)) {
+ throw newValidationError(operands.get(0),
+ RESOURCE.patternVarAlreadyDefined(leftString));
+ }
+ scope.addPatternVar(leftString);
+ for (SqlNode right : (SqlNodeList) operands.get(1)) {
+ SqlIdentifier id = (SqlIdentifier) right;
+ if (!scope.getPatternVars().contains(id.getSimple())) {
+ throw newValidationError(id,
+ RESOURCE.unknownPattern(id.getSimple()));
+ }
+ scope.addPatternVar(id.getSimple());
+ }
+ }
+ }
+
+ // validate AFTER ... SKIP TO
+ final SqlNode skipTo = matchRecognize.getAfter();
+ if (skipTo instanceof SqlCall) {
+ final SqlCall skipToCall = (SqlCall) skipTo;
+ final SqlIdentifier id = skipToCall.operand(0);
+ if (!scope.getPatternVars().contains(id.getSimple())) {
+ throw newValidationError(id,
+ RESOURCE.unknownPattern(id.getSimple()));
+ }
+ }
+
+ List<Map.Entry<String, RelDataType>> measureColumns =
+ validateMeasure(matchRecognize, scope, allRows);
+ for (Map.Entry<String, RelDataType> c : measureColumns) {
+ if (!typeBuilder.nameExists(c.getKey())) {
+ typeBuilder.add(c.getKey(), c.getValue());
+ }
+ }
+
+ final RelDataType rowType = typeBuilder.build();
+ if (matchRecognize.getMeasureList().size() == 0) {
+ ns.setType(getNamespace(matchRecognize.getTableRef()).getRowType());
+ } else {
+ ns.setType(rowType);
+ }
+ }
+
+ private List<Map.Entry<String, RelDataType>> validateMeasure(SqlMatchRecognize mr,
+ MatchRecognizeScope scope, boolean allRows) {
+ final List<String> aliases = new ArrayList<>();
+ final List<SqlNode> sqlNodes = new ArrayList<>();
+ final SqlNodeList measures = mr.getMeasureList();
+ final List<Map.Entry<String, RelDataType>> fields = new ArrayList<>();
+
+ for (SqlNode measure : measures) {
+ assert measure instanceof SqlCall;
+ final String alias = deriveAlias(measure, aliases.size());
+ aliases.add(alias);
+
+ SqlNode expand = expand(measure, scope);
+ expand = navigationInMeasure(expand, allRows);
+ setOriginal(expand, measure);
+
+ inferUnknownTypes(unknownType, scope, expand);
+ final RelDataType type = deriveType(scope, expand);
+ setValidatedNodeType(measure, type);
+
+ fields.add(Pair.of(alias, type));
+ sqlNodes.add(
+ SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO, expand,
+ new SqlIdentifier(alias, SqlParserPos.ZERO)));
+ }
+
+ SqlNodeList list = new SqlNodeList(sqlNodes, measures.getParserPosition());
+ inferUnknownTypes(unknownType, scope, list);
+
+ for (SqlNode node : list) {
+ validateExpr(node, scope);
+ }
+
+ mr.setOperand(SqlMatchRecognize.OPERAND_MEASURES, list);
+
+ return fields;
+ }
+
+ private SqlNode navigationInMeasure(SqlNode node, boolean allRows) {
+ 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;
+ }
+
+ private void validateDefinitions(SqlMatchRecognize mr,
+ MatchRecognizeScope scope) {
+ final Set<String> aliases = catalogReader.nameMatcher().createSet();
+ for (SqlNode item : mr.getPatternDefList().getList()) {
+ final String alias = alias(item);
+ if (!aliases.add(alias)) {
+ throw newValidationError(item,
+ Static.RESOURCE.patternVarAlreadyDefined(alias));
+ }
+ scope.addPatternVar(alias);
+ }
+
+ final List<SqlNode> sqlNodes = new ArrayList<>();
+ for (SqlNode item : mr.getPatternDefList().getList()) {
+ final String alias = alias(item);
+ SqlNode expand = expand(item, scope);
+ expand = navigationInDefine(expand, alias);
+ setOriginal(expand, item);
+
+ inferUnknownTypes(booleanType, scope, expand);
+ expand.validate(this, scope);
+
+ // Some extra work need required here.
+ // In PREV, NEXT, FINAL and LAST, only one pattern variable is allowed.
+ sqlNodes.add(
+ SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO, expand,
+ new SqlIdentifier(alias, SqlParserPos.ZERO)));
+
+ final RelDataType type = deriveType(scope, expand);
+ if (!SqlTypeUtil.inBooleanFamily(type)) {
+ throw newValidationError(expand, RESOURCE.condMustBeBoolean("DEFINE"));
+ }
+ setValidatedNodeType(item, type);
+ }
+
+ SqlNodeList list =
+ new SqlNodeList(sqlNodes, mr.getPatternDefList().getParserPosition());
+ inferUnknownTypes(unknownType, scope, list);
+ for (SqlNode node : list) {
+ validateExpr(node, scope);
+ }
+ mr.setOperand(SqlMatchRecognize.OPERAND_PATTERN_DEFINES, list);
+ }
+
+ /** Returns the alias of a "expr AS alias" expression. */
+ private static String alias(SqlNode item) {
+ assert item instanceof SqlCall;
+ assert item.getKind() == SqlKind.AS;
+ final SqlIdentifier identifier = ((SqlCall) item).operand(1);
+ return identifier.getSimple();
+ }
+
+ /** Checks that all pattern variables within a function are the same,
+ * and canonizes expressions such as {@code PREV(B.price)} to
+ * {@code LAST(B.price, 0)}. */
+ private SqlNode navigationInDefine(SqlNode node, String alpha) {
+ Set<String> prefix = node.accept(new PatternValidator(false));
+ Util.discard(prefix);
+ node = new NavigationExpander().go(node);
+ node = new NavigationReplacer(alpha).go(node);
+ return node;
+ }
+
+ public void validateAggregateParams(SqlCall aggCall, SqlNode filter,
+ SqlValidatorScope scope) {
+ // For "agg(expr)", expr cannot itself contain aggregate function
+ // invocations. For example, "SUM(2 * MAX(x))" is illegal; when
+ // we see it, we'll report the error for the SUM (not the MAX).
+ // For more than one level of nesting, the error which results
+ // depends on the traversal order for validation.
+ //
+ // For a windowed aggregate "agg(expr)", expr can contain an aggregate
+ // function. For example,
+ // SELECT AVG(2 * MAX(x)) OVER (PARTITION BY y)
+ // FROM t
+ // GROUP BY y
+ // is legal. Only one level of nesting is allowed since non-windowed
+ // aggregates cannot nest aggregates.
+
+ // Store nesting level of each aggregate. If an aggregate is found at an invalid
+ // nesting level, throw an assert.
+ final AggFinder a;
+ if (inWindow) {
+ a = overFinder;
+ } else {
+ a = aggOrOverFinder;
+ }
+
+ for (SqlNode param : aggCall.getOperandList()) {
+ if (a.findAgg(param) != null) {
+ throw newValidationError(aggCall, RESOURCE.nestedAggIllegal());
+ }
+ }
+ if (filter != null) {
+ if (a.findAgg(filter) != null) {
+ throw newValidationError(filter, RESOURCE.aggregateInFilterIllegal());
+ }
+ }
+ }
+
+ public void validateCall(
+ SqlCall call,
+ SqlValidatorScope scope) {
+ final SqlOperator operator = call.getOperator();
+ if ((call.operandCount() == 0)
+ && (operator.getSyntax() == SqlSyntax.FUNCTION_ID)
+ && !call.isExpanded()
+ && !conformance.allowNiladicParentheses()) {
+ // For example, "LOCALTIME()" is illegal. (It should be
+ // "LOCALTIME", which would have been handled as a
+ // SqlIdentifier.)
+ throw handleUnresolvedFunction(call, (SqlFunction) operator,
+ ImmutableList.of(), null);
+ }
+
+ SqlValidatorScope operandScope = scope.getOperandScope(call);
+
+ if (operator instanceof SqlFunction
+ && ((SqlFunction) operator).getFunctionType()
+ == SqlFunctionCategory.MATCH_RECOGNIZE
+ && !(operandScope instanceof MatchRecognizeScope)) {
+ throw newValidationError(call,
+ Static.RESOURCE.functionMatchRecognizeOnly(call.toString()));
+ }
+ // Delegate validation to the operator.
+ operator.validateCall(call, this, scope, operandScope);
+ }
+
+ /**
+ * Validates that a particular feature is enabled. By default, all features
+ * are enabled; subclasses may override this method to be more
+ * discriminating.
+ *
+ * @param feature feature being used, represented as a resource instance
+ * @param context parser position context for error reporting, or null if
+ */
+ protected void validateFeature(
+ Feature feature,
+ SqlParserPos context) {
+ // By default, do nothing except to verify that the resource
+ // represents a real feature definition.
+ assert feature.getProperties().get("FeatureDefinition") != null;
+ }
+
+ public SqlNode expand(SqlNode expr, SqlValidatorScope scope) {
+ final Expander expander = new Expander(this, scope);
+ SqlNode newExpr = expr.accept(expander);
+ if (expr != newExpr) {
+ setOriginal(newExpr, expr);
+ }
+ return newExpr;
+ }
+
+ public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
+ SqlValidatorScope scope, SqlSelect select, boolean havingExpression) {
+ final Expander expander = new ExtendedExpander(this, scope, select, expr,
+ havingExpression);
+ SqlNode newExpr = expr.accept(expander);
+ if (expr != newExpr) {
+ setOriginal(newExpr, expr);
+ }
+ return newExpr;
+ }
+
+ public boolean isSystemField(RelDataTypeField field) {
+ return false;
+ }
+
+ public List<List<String>> getFieldOrigins(SqlNode sqlQuery) {
+ 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);
+ }
+
+ private List<String> getFieldOrigin(SqlNode sqlQuery, int i) {
+ 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;
+ }
+ }
+
+ public RelDataType getParameterRowType(SqlNode sqlQuery) {
+ // 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();
+ }
+ });
+ }
+
+ public void validateColumnListParams(
+ SqlFunction function,
+ List<RelDataType> argTypes,
+ List<SqlNode> operands) {
+ throw new UnsupportedOperationException();
+ }
+
+ private static boolean isPhysicalNavigation(SqlKind kind) {
+ return kind == SqlKind.PREV || kind == SqlKind.NEXT;
+ }
+
+ private static boolean isLogicalNavigation(SqlKind kind) {
+ return kind == SqlKind.FIRST || kind == SqlKind.LAST;
+ }
+
+ private static boolean isAggregation(SqlKind kind) {
+ return kind == SqlKind.SUM || kind == SqlKind.SUM0
+ || kind == SqlKind.AVG || kind == SqlKind.COUNT
+ || kind == SqlKind.MAX || kind == SqlKind.MIN;
+ }
+
+ private static boolean isRunningOrFinal(SqlKind kind) {
+ return kind == SqlKind.RUNNING || kind == SqlKind.FINAL;
+ }
+
+ private static boolean isSingleVarRequired(SqlKind kind) {
+ return isPhysicalNavigation(kind)
+ || isLogicalNavigation(kind)
+ || isAggregation(kind);
+ }
+
+ //~ Inner Classes ----------------------------------------------------------
+
+ /**
+ * Common base class for DML statement namespaces.
+ */
+ public static class DmlNamespace extends IdentifierNamespace {
+ protected DmlNamespace(SqlValidatorImpl validator, SqlNode id,
+ SqlNode enclosingNode, SqlValidatorScope parentScope) {
+ super(validator, id, enclosingNode, parentScope);
+ }
+ }
+
+ /**
+ * Namespace for an INSERT statement.
+ */
+ private static class InsertNamespace extends DmlNamespace {
+ private final SqlInsert node;
+
+ InsertNamespace(SqlValidatorImpl validator, SqlInsert node,
+ SqlNode enclosingNode, SqlValidatorScope parentScope) {
+ super(validator, node.getTargetTable(), enclosingNode, parentScope);
+ this.node = Objects.requireNonNull(node);
+ }
+
+ public SqlInsert getNode() {
+ return node;
+ }
+ }
+
+ /**
+ * Namespace for an UPDATE statement.
+ */
+ private static class UpdateNamespace extends DmlNamespace {
+ private final SqlUpdate node;
+
+ UpdateNamespace(SqlValidatorImpl validator, SqlUpdate node,
+ SqlNode enclosingNode, SqlValidatorScope parentScope) {
+ super(validator, node.getTargetTable(), enclosingNode, parentScope);
+ this.node = Objects.requireNonNull(node);
+ }
+
+ public SqlUpdate getNode() {
+ return node;
+ }
+ }
+
+ /**
+ * Namespace for a DELETE statement.
+ */
+ private static class DeleteNamespace extends DmlNamespace {
+ private final SqlDelete node;
+
+ DeleteNamespace(SqlValidatorImpl validator, SqlDelete node,
+ SqlNode enclosingNode, SqlValidatorScope parentScope) {
+ super(validator, node.getTargetTable(), enclosingNode, parentScope);
+ this.node = Objects.requireNonNull(node);
+ }
+
+ public SqlDelete getNode() {
+ return node;
+ }
+ }
+
+ /**
+ * Namespace for a MERGE statement.
+ */
+ private static class MergeNamespace extends DmlNamespace {
+ private final SqlMerge node;
+
+ MergeNamespace(SqlValidatorImpl validator, SqlMerge node,
+ SqlNode enclosingNode, SqlValidatorScope parentScope) {
+ super(validator, node.getTargetTable(), enclosingNode, parentScope);
+ this.node = Objects.requireNonNull(node);
+ }
+
+ public SqlMerge getNode() {
+ return node;
+ }
+ }
+
+ /**
+ * retrieve pattern variables defined
+ */
+ private class PatternVarVisitor implements SqlVisitor<Void> {
+ private MatchRecognizeScope scope;
+ PatternVarVisitor(MatchRecognizeScope scope) {
+ this.scope = scope;
+ }
+
+ @Override public Void visit(SqlLiteral literal) {
+ return null;
+ }
+
+ @Override public Void visit(SqlCall call) {
+ for (int i = 0; i < call.getOperandList().size(); i++) {
+ call.getOperandList().get(i).accept(this);
+ }
+ return null;
+ }
+
+ @Override public Void visit(SqlNodeList nodeList) {
+ throw Util.needToImplement(nodeList);
+ }
+
+ @Override public Void visit(SqlIdentifier id) {
+ Preconditions.checkArgument(id.isSimple());
+ scope.addPatternVar(id.getSimple());
+ return null;
+ }
+
+ @Override public Void visit(SqlDataTypeSpec type) {
+ throw Util.needToImplement(type);
+ }
+
+ @Override public Void visit(SqlDynamicParam param) {
+ throw Util.needToImplement(param);
+ }
+
+ @Override public Void visit(SqlIntervalQualifier intervalQualifier) {
+ throw Util.needToImplement(intervalQualifier);
+ }
+ }
+
+ /**
+ * Visitor which derives the type of a given {@link SqlNode}.
+ *
+ * <p>Each method must return the derived type. This visitor is basically a
+ * single-use dispatcher; the visit is never recursive.
+ */
+ private class DeriveTypeVisitor implements SqlVisitor<RelDataType> {
+ private final SqlValidatorScope scope;
+
+ DeriveTypeVisitor(SqlValidatorScope scope) {
+ this.scope = scope;
+ }
+
+ public RelDataType visit(SqlLiteral literal) {
+ return literal.createSqlType(typeFactory);
+ }
+
+ public RelDataType visit(SqlCall call) {
+ final SqlOperator operator = call.getOperator();
+ return operator.deriveType(SqlValidatorImpl.this, scope, call);
+ }
+
+ public RelDataType visit(SqlNodeList nodeList) {
+ // Operand is of a type that we can't derive a type for. If the
+ // operand is of a peculiar type, such as a SqlNodeList, then you
+ // should override the operator's validateCall() method so that it
+ // doesn't try to validate that operand as an expression.
+ throw Util.needToImplement(nodeList);
+ }
+
+ public RelDataType visit(SqlIdentifier id) {
+ // First check for builtin functions which don't have parentheses,
+ // like "LOCALTIME".
+ SqlCall call = SqlUtil.makeCall(opTab, id);
+ if (call != null) {
+ return call.getOperator().validateOperands(
+ SqlValidatorImpl.this,
+ scope,
+ call);
+ }
+
+ RelDataType type = null;
+ if (!(scope instanceof EmptyScope)) {
+ id = scope.fullyQualify(id).identifier;
+ }
+
+ // Resolve the longest prefix of id that we can
+ int i;
+ for (i = id.names.size() - 1; i > 0; i--) {
+ // REVIEW jvs 9-June-2005: The name resolution rules used
+ // here are supposed to match SQL:2003 Part 2 Section 6.6
+ // (identifier chain), but we don't currently have enough
+ // information to get everything right. In particular,
+ // routine parameters are currently looked up via resolve;
+ // we could do a better job if they were looked up via
+ // resolveColumn.
+
+ final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+ final SqlValidatorScope.ResolvedImpl resolved =
+ new SqlValidatorScope.ResolvedImpl();
+ scope.resolve(id.names.subList(0, i), nameMatcher, false, resolved);
+ if (resolved.count() == 1) {
+ // There's a namespace with the name we seek.
+ final SqlValidatorScope.Resolve resolve = resolved.only();
+ type = resolve.rowType();
+ for (SqlValidatorScope.Step p : Util.skip(resolve.path.steps())) {
+ type = type.getFieldList().get(p.i).getType();
+ }
+ break;
+ }
+ }
+
+ // Give precedence to namespace found, unless there
+ // are no more identifier components.
+ if (type == null || id.names.size() == 1) {
+ // See if there's a column with the name we seek in
+ // precisely one of the namespaces in this scope.
+ RelDataType colType = scope.resolveColumn(id.names.get(0), id);
+ if (colType != null) {
+ type = colType;
+ }
+ ++i;
+ }
+
+ if (type == null) {
+ final SqlIdentifier last = id.getComponent(i - 1, i);
+ throw newValidationError(last,
+ RESOURCE.unknownIdentifier(last.toString()));
+ }
+
+ // Resolve rest of identifier
+ for (; i < id.names.size(); i++) {
+ String name = id.names.get(i);
+ final RelDataTypeField field;
+ if (name.equals("")) {
+ // The wildcard "*" is represented as an empty name. It never
+ // resolves to a field.
+ name = "*";
+ field = null;
+ } else {
+ final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+ field = nameMatcher.field(type, name);
+ }
+ if (field == null) {
+ throw newValidationError(id.getComponent(i),
+ RESOURCE.unknownField(name));
+ }
+ type = field.getType();
+ }
+ type =
+ SqlTypeUtil.addCharsetAndCollation(
+ type,
+ getTypeFactory());
+ return type;
+ }
+
+ public RelDataType visit(SqlDataTypeSpec dataType) {
+ // Q. How can a data type have a type?
+ // A. When it appears in an expression. (Say as the 2nd arg to the
+ // CAST operator.)
+ validateDataType(dataType);
+ return dataType.deriveType(SqlValidatorImpl.this);
+ }
+
+ public RelDataType visit(SqlDynamicParam param) {
+ return unknownType;
+ }
+
+ public RelDataType visit(SqlIntervalQualifier intervalQualifier) {
+ return typeFactory.createSqlIntervalType(intervalQualifier);
+ }
+ }
+
+ /**
+ * Converts an expression into canonical form by fully-qualifying any
+ * identifiers.
+ */
+ private static class Expander extends SqlScopedShuttle {
+ protected final SqlValidatorImpl validator;
+
+ Expander(SqlValidatorImpl validator, SqlValidatorScope scope) {
+ super(scope);
+ this.validator = validator;
+ }
+
+ @Override public SqlNode visit(SqlIdentifier id) {
+ // First check for builtin functions which don't have
+ // parentheses, like "LOCALTIME".
+ SqlCall call =
+ SqlUtil.makeCall(
+ validator.getOperatorTable(),
+ id);
+ if (call != null) {
+ return call.accept(this);
+ }
+ final SqlIdentifier fqId = getScope().fullyQualify(id).identifier;
+ SqlNode expandedExpr = fqId;
+ // Convert a column ref into ITEM(*, 'col_name').
+ // select col_name from (select * from dynTable)
+ // SqlIdentifier "col_name" would be resolved to a dynamic star field in dynTable's rowType.
+ // Expand such SqlIdentifier to ITEM operator.
+ if (DynamicRecordType.isDynamicStarColName(Util.last(fqId.names))
+ && !DynamicRecordType.isDynamicStarColName(Util.last(id.names))) {
+ SqlNode[] inputs = new SqlNode[2];
+ inputs[0] = fqId;
+ inputs[1] = SqlLiteral.createCharString(
+ Util.last(id.names),
+ id.getParserPosition());
+ SqlBasicCall item_call = new SqlBasicCall(
+ SqlStdOperatorTable.ITEM,
+ inputs,
+ id.getParserPosition());
+ expandedExpr = item_call;
+ }
+ validator.setOriginal(expandedExpr, id);
+ return expandedExpr;
+ }
+
+ @Override protected SqlNode visitScoped(SqlCall call) {
+ switch (call.getKind()) {
+ case SCALAR_QUERY:
+ case CURRENT_VALUE:
+ case NEXT_VALUE:
+ case WITH:
+ return call;
+ }
+ // Only visits arguments which are expressions. We don't want to
+ // qualify non-expressions such as 'x' in 'empno * 5 AS x'.
+ ArgHandler<SqlNode> argHandler =
+ new CallCopyingArgHandler(call, false);
+ call.getOperator().acceptCall(this, call, true, argHandler);
+ final SqlNode result = argHandler.result();
+ validator.setOriginal(result, call);
+ return result;
+ }
+ }
+
+ /**
+ * Shuttle which walks over an expression in the ORDER BY clause, replacing
+ * usages of aliases with the underlying expression.
+ */
+ class OrderExpressionExpander extends SqlScopedShuttle {
+ private final List<String> aliasList;
+ private final SqlSelect select;
+ private final SqlNode root;
+
+ OrderExpressionExpander(SqlSelect select, SqlNode root) {
+ super(getOrderScope(select));
+ this.select = select;
+ this.root = root;
+ this.aliasList = getNamespace(select).getRowType().getFieldNames();
+ }
+
+ public SqlNode go() {
+ return root.accept(this);
+ }
+
+ public SqlNode visit(SqlLiteral literal) {
+ // Ordinal markers, e.g. 'select a, b from t order by 2'.
+ // Only recognize them if they are the whole expression,
+ // and if the dialect permits.
+ if (literal == root && getConformance().isSortByOrdinal()) {
+ switch (literal.getTypeName()) {
+ case DECIMAL:
+ case DOUBLE:
+ final int intValue = literal.intValue(false);
+ if (intValue >= 0) {
+ if (intValue < 1 || intValue > aliasList.size()) {
+ throw newValidationError(
+ literal, RESOURCE.orderByOrdinalOutOfRange());
+ }
+
+ // SQL ordinals are 1-based, but Sort's are 0-based
+ int ordinal = intValue - 1;
+ return nthSelectItem(ordinal, literal.getParserPosition());
+ }
+ break;
+ }
+ }
+
+ return super.visit(literal);
+ }
+
+ /**
+ * Returns the <code>ordinal</code>th item in the select list.
+ */
+ private SqlNode nthSelectItem(int ordinal, final SqlParserPos pos) {
+ // TODO: Don't expand the list every time. Maybe keep an expanded
+ // version of each expression -- select lists and identifiers -- in
+ // the validator.
+
+ SqlNodeList expandedSelectList =
+ expandStar(
+ select.getSelectList(),
+ select,
+ false);
+ SqlNode expr = expandedSelectList.get(ordinal);
+ expr = stripAs(expr);
+ if (expr instanceof SqlIdentifier) {
+ expr = getScope().fullyQualify((SqlIdentifier) expr).identifier;
+ }
+
+ // Create a copy of the expression with the position of the order
+ // item.
+ return expr.clone(pos);
+ }
+
+ public SqlNode visit(SqlIdentifier id) {
+ // Aliases, e.g. 'select a as x, b from t order by x'.
+ if (id.isSimple()
+ && getConformance().isSortByAlias()) {
+ String alias = id.getSimple();
+ final SqlValidatorNamespace selectNs = getNamespace(select);
+ final RelDataType rowType =
+ selectNs.getRowTypeSansSystemColumns();
+ final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+ RelDataTypeField field = nameMatcher.field(rowType, alias);
+ if (field != null) {
+ return nthSelectItem(
+ field.getIndex(),
+ id.getParserPosition());
+ }
+ }
+
+ // No match. Return identifier unchanged.
+ return getScope().fullyQualify(id).identifier;
+ }
+
+ protected SqlNode visitScoped(SqlCall call) {
+ // Don't attempt to expand sub-queries. We haven't implemented
+ // these yet.
+ if (call instanceof SqlSelect) {
+ return call;
+ }
+ return super.visitScoped(call);
+ }
+ }
+
+ /**
+ * Shuttle which walks over an expression in the GROUP BY/HAVING clause, replacing
+ * usages of aliases or ordinals with the underlying expression.
+ */
+ static class ExtendedExpander extends Expander {
+ final SqlSelect select;
+ final SqlNode root;
+ final boolean havingExpr;
+
+ ExtendedExpander(SqlValidatorImpl validator, SqlValidatorScope scope,
+ SqlSelect select, SqlNode root, boolean havingExpr) {
+ super(validator, scope);
+ this.select = select;
+ this.root = root;
+ this.havingExpr = havingExpr;
+ }
+
+ @Override public SqlNode visit(SqlIdentifier id) {
+ if (id.isSimple()
+ && (havingExpr
+ ? validator.getConformance().isHavingAlias()
+ : validator.getConformance().isGroupByAlias())) {
+ String name = id.getSimple();
+ SqlNode expr = null;
+ final SqlNameMatcher nameMatcher =
+ validator.catalogReader.nameMatcher();
+ int n = 0;
+ for (SqlNode s : select.getSelectList()) {
+ final String alias = SqlValidatorUtil.getAlias(s, -1);
+ if (alias != null && nameMatcher.matches(alias, name)) {
+ expr = s;
+ n++;
+ }
+ }
+ if (n == 0) {
+ return super.visit(id);
+ } else if (n > 1) {
+ // More than one column has this alias.
+ throw validator.newValidationError(id,
+ RESOURCE.columnAmbiguous(name));
+ }
+ if (havingExpr && validator.isAggregate(root)) {
+ return super.visit(id);
+ }
+ expr = stripAs(expr);
+ if (expr instanceof SqlIdentifier) {
+ expr = getScope().fullyQualify((SqlIdentifier) expr).identifier;
+ }
+ return expr;
+ }
+ return super.visit(id);
+ }
+
+ public SqlNode visit(SqlLiteral literal) {
+ if (havingExpr || !validator.getConformance().isGroupByOrdinal()) {
+ return super.visit(literal);
+ }
+ boolean isOrdinalLiteral = literal == root;
+ switch (root.getKind()) {
+ case GROUPING_SETS:
+ case ROLLUP:
+ case CUBE:
+ if (root instanceof SqlBasicCall) {
+ List<SqlNode> operandList = ((SqlBasicCall) root).getOperandList();
+ for (SqlNode node : operandList) {
+ if (node.equals(literal)) {
+ isOrdinalLiteral = true;
+ break;
+ }
+ }
+ }
+ break;
+ }
+ if (isOrdinalLiteral) {
+ switch (literal.getTypeName()) {
+ case DECIMAL:
+ case DOUBLE:
+ final int intValue = literal.intValue(false);
+ if (intValue >= 0) {
+ if (intValue < 1 || intValue > select.getSelectList().size()) {
+ throw validator.newValidationError(literal,
+ RESOURCE.orderByOrdinalOutOfRange());
+ }
+
+ // SQL ordinals are 1-based, but Sort's are 0-based
+ int ordinal = intValue - 1;
+ return SqlUtil.stripAs(select.getSelectList().get(ordinal));
+ }
+ break;
+ }
+ }
+
+ return super.visit(literal);
+ }
+ }
+
+ /** Information about an identifier in a particular scope. */
+ protected static class IdInfo {
+ public final SqlValidatorScope scope;
+ public final SqlIdentifier id;
+
+ public IdInfo(SqlValidatorScope scope, SqlIdentifier id) {
+ this.scope = scope;
+ this.id = id;
+ }
+ }
+
+ /**
+ * Utility object used to maintain information about the parameters in a
+ * function call.
+ */
+ protected static class FunctionParamInfo {
+ /**
+ * Maps a cursor (based on its position relative to other cursor
+ * parameters within a function call) to the SELECT associated with the
+ * cursor.
+ */
+ public final Map<Integer, SqlSelect> cursorPosToSelectMap;
+
+ /**
+ * Maps a column list parameter to the parent cursor parameter it
+ * references. The parameters are id'd by their names.
+ */
+ public final Map<String, String> columnListParamToParentCursorMap;
+
+ public FunctionParamInfo() {
+ cursorPosToSelectMap = new HashMap<>();
+ columnListParamToParentCursorMap = new HashMap<>();
+ }
+ }
+
+ /**
+ * Modify the nodes in navigation function
+ * such as FIRST, LAST, PREV AND NEXT.
+ */
+ private static class NavigationModifier extends SqlShuttle {
+ public SqlNode go(SqlNode node) {
+ return node.accept(this);
+ }
+ }
+
+ /**
+ * Shuttle that expands navigation expressions in a MATCH_RECOGNIZE clause.
+ *
+ * <p>Examples:
+ *
+ * <ul>
+ * <li>{@code PREV(A.price + A.amount)} →
+ * {@code PREV(A.price) + PREV(A.amount)}
+ *
+ * <li>{@code FIRST(A.price * 2)} → {@code FIRST(A.PRICE) * 2}
+ * </ul>
+ */
+ private static class NavigationExpander extends NavigationModifier {
+ final SqlOperator op;
+ final SqlNode offset;
+
+ NavigationExpander() {
+ this(null, null);
+ }
+
+ NavigationExpander(SqlOperator operator, SqlNode offset) {
+ this.offset = offset;
+ this.op = operator;
+ }
+
+ @Override public SqlNode visit(SqlCall call) {
+ SqlKind kind = call.getKind();
+ List<SqlNode> operands = call.getOperandList();
+ List<SqlNode> newOperands = new ArrayList<>();
+
+ // This code is a workaround for CALCITE-2707
+ if (call.getFunctionQuantifier() != null
+ && call.getFunctionQuantifier().getValue() == SqlSelectKeyword.DISTINCT) {
+ final SqlParserPos pos = call.getParserPosition();
+ throw SqlUtil.newContextException(pos, Static.RESOURCE.functionQuantifierNotAllowed(call.toString()));
+ }
+ // This code is a workaround for CALCITE-2707
+
+ if (isLogicalNavigation(kind) || isPhysicalNavigation(kind)) {
+ SqlNode inner = operands.get(0);
+ SqlNode offset = operands.get(1);
+
+ // merge two straight prev/next, update offset
+ if (isPhysicalNavigation(kind)) {
+ SqlKind innerKind = inner.getKind();
+ if (isPhysicalNavigation(innerKind)) {
+ List<SqlNode> innerOperands = ((SqlCall) inner).getOperandList();
+ SqlNode innerOffset = innerOperands.get(1);
+ SqlOperator newOperator = innerKind == kind
+ ? SqlStdOperatorTable.PLUS : SqlStdOperatorTable.MINUS;
+ offset = newOperator.createCall(SqlParserPos.ZERO,
+ offset, innerOffset);
+ inner = call.getOperator().createCall(SqlParserPos.ZERO,
+ innerOperands.get(0), offset);
+ }
+ }
+ SqlNode newInnerNode =
+ inner.accept(new NavigationExpander(call.getOperator(), offset));
+ if (op != null) {
+ newInnerNode = op.createCall(SqlParserPos.ZERO, newInnerNode,
+ this.offset);
+ }
+ return newInnerNode;
+ }
+
+ if (operands.size() > 0) {
+ for (SqlNode node : operands) {
+ if (node != null) {
+ SqlNode newNode = node.accept(new NavigationExpander());
+ if (op != null) {
+ newNode = op.createCall(SqlParserPos.ZERO, newNode, offset);
+ }
+ newOperands.add(newNode);
+ } else {
+ newOperands.add(null);
+ }
+ }
+ return call.getOperator().createCall(SqlParserPos.ZERO, newOperands);
+ } else {
+ if (op == null) {
+ return call;
+ } else {
+ return op.createCall(SqlParserPos.ZERO, call, offset);
+ }
+ }
+ }
+
+ @Override public SqlNode visit(SqlIdentifier id) {
+ if (op == null) {
+ return id;
+ } else {
+ return op.createCall(SqlParserPos.ZERO, id, offset);
+ }
+ }
+ }
+
+ /**
+ * Shuttle that replaces {@code A as A.price > PREV(B.price)} with
+ * {@code PREV(A.price, 0) > LAST(B.price, 0)}.
+ *
+ * <p>Replacing {@code A.price} with {@code PREV(A.price, 0)} makes the
+ * implementation of
+ * {@link RexVisitor#visitPatternFieldRef(RexPatternFieldRef)} more unified.
+ * Otherwise, it's difficult to implement this method. If it returns the
+ * specified field, then the navigation such as {@code PREV(A.price, 1)}
+ * becomes impossible; if not, then comparisons such as
+ * {@code A.price > PREV(A.price, 1)} become meaningless.
+ */
+ private static class NavigationReplacer extends NavigationModifier {
+ private final String alpha;
+
+ NavigationReplacer(String alpha) {
+ this.alpha = alpha;
+ }
+
+ @Override public SqlNode visit(SqlCall call) {
+ SqlKind kind = call.getKind();
+ if (isLogicalNavigation(kind)
+ || isAggregation(kind)
+ || isRunningOrFinal(kind)) {
+ return call;
+ }
+
+ switch (kind) {
+ case PREV:
+ final List<SqlNode> operands = call.getOperandList();
+ if (operands.get(0) instanceof SqlIdentifier) {
+ String name = ((SqlIdentifier) operands.get(0)).names.get(0);
+ return name.equals(alpha) ? call
+ : SqlStdOperatorTable.LAST.createCall(SqlParserPos.ZERO, operands);
+ }
+ }
+ return super.visit(call);
+ }
+
+ @Override public SqlNode visit(SqlIdentifier id) {
+ if (id.isSimple()) {
+ return id;
+ }
+ SqlOperator operator = id.names.get(0).equals(alpha)
+ ? SqlStdOperatorTable.PREV : SqlStdOperatorTable.LAST;
+
+ return operator.createCall(SqlParserPos.ZERO, id,
+ SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO));
+ }
+ }
+
+ /**
+ * Within one navigation function, the pattern var should be same
+ */
+ private class PatternValidator extends SqlBasicVisitor<Set<String>> {
+ private final boolean isMeasure;
+ int firstLastCount;
+ int prevNextCount;
+ int aggregateCount;
+
+ PatternValidator(boolean isMeasure) {
+ this(isMeasure, 0, 0, 0);
+ }
+
+ PatternValidator(boolean isMeasure, int firstLastCount, int prevNextCount,
+ int aggregateCount) {
+ this.isMeasure = isMeasure;
+ this.firstLastCount = firstLastCount;
+ this.prevNextCount = prevNextCount;
+ this.aggregateCount = aggregateCount;
+ }
+
+ @Override public Set<String> visit(SqlCall call) {
+ boolean isSingle = false;
+ Set<String> vars = new HashSet<>();
+ SqlKind kind = call.getKind();
+ List<SqlNode> operands = call.getOperandList();
+
+ if (isSingleVarRequired(kind)) {
+ isSingle = true;
+ if (isPhysicalNavigation(kind)) {
+ if (isMeasure) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternPrevFunctionInMeasure(call.toString()));
+ }
+ if (firstLastCount != 0) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternPrevFunctionOrder(call.toString()));
+ }
+ prevNextCount++;
+ } else if (isLogicalNavigation(kind)) {
+ if (firstLastCount != 0) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternPrevFunctionOrder(call.toString()));
+ }
+ firstLastCount++;
+ } else if (isAggregation(kind)) {
+ // cannot apply aggregation in PREV/NEXT, FIRST/LAST
+ if (firstLastCount != 0 || prevNextCount != 0) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternAggregationInNavigation(call.toString()));
+ }
+ if (kind == SqlKind.COUNT && call.getOperandList().size() > 1) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternCountFunctionArg());
+ }
+ aggregateCount++;
+ }
+ }
+
+ if (isRunningOrFinal(kind) && !isMeasure) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternRunningFunctionInDefine(call.toString()));
+ }
+
+ for (SqlNode node : operands) {
+ if (node != null) {
+ vars.addAll(
+ node.accept(
+ new PatternValidator(isMeasure, firstLastCount, prevNextCount,
+ aggregateCount)));
+ }
+ }
+
+ if (isSingle) {
+ switch (kind) {
+ case COUNT:
+ if (vars.size() > 1) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternCountFunctionArg());
+ }
+ break;
+ default:
+ if (operands.size() == 0
+ || !(operands.get(0) instanceof SqlCall)
+ || ((SqlCall) operands.get(0)).getOperator() != SqlStdOperatorTable.CLASSIFIER) {
+ if (vars.isEmpty()) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternFunctionNullCheck(call.toString()));
+ }
+ if (vars.size() != 1) {
+ throw newValidationError(call,
+ Static.RESOURCE.patternFunctionVariableCheck(call.toString()));
+ }
+ }
+ break;
+ }
+ }
+ return vars;
+ }
+
+ @Override public Set<String> visit(SqlIdentifier identifier) {
+ boolean check = prevNextCount > 0 || firstLastCount > 0 || aggregateCount > 0;
+ Set<String> vars = new HashSet<>();
+ if (identifier.names.size() > 1 && check) {
+ vars.add(identifier.names.get(0));
+ }
+ return vars;
+ }
+
+ @Override public Set<String> visit(SqlLiteral literal) {
+ return ImmutableSet.of();
+ }
+
+ @Override public Set<String> visit(SqlIntervalQualifier qualifier) {
+ return ImmutableSet.of();
+ }
+
+ @Override public Set<String> visit(SqlDataTypeSpec type) {
+ return ImmutableSet.of();
+ }
+
+ @Override public Set<String> visit(SqlDynamicParam param) {
+ return ImmutableSet.of();
+ }
+ }
+
+ /** Permutation of fields in NATURAL JOIN or USING. */
+ private class Permute {
+ final List<ImmutableIntList> sources;
+ final RelDataType rowType;
+ final boolean trivial;
+
+ Permute(SqlNode from, int offset) {
+ switch (from.getKind()) {
+ case JOIN:
+ final SqlJoin join = (SqlJoin) from;
+ final Permute left = new Permute(join.getLeft(), offset);
+ final int fieldCount =
+ getValidatedNodeType(join.getLeft()).getFieldList().size();
+ final Permute right =
+ new Permute(join.getRight(), offset + fieldCount);
+ final List<String> names = usingNames(join);
+ final List<ImmutableIntList> sources = new ArrayList<>();
+ final Set<ImmutableIntList> sourceSet = new HashSet<>();
+ final RelDataTypeFactory.Builder b = typeFactory.builder();
+ if (names != null) {
+ for (String name : names) {
+ final RelDataTypeField f = left.field(name);
+ final ImmutableIntList source = left.sources.get(f.getIndex());
+ sourceSet.add(source);
+ final RelDataTypeField f2 = right.field(name);
+ final ImmutableIntList source2 = right.sources.get(f2.getIndex());
+ sourceSet.add(source2);
+ sources.add(source.appendAll(source2));
+ final boolean nullable =
+ (f.getType().isNullable()
+ || join.getJoinType().generatesNullsOnLeft())
+ && (f2.getType().isNullable()
+ || join.getJoinType().generatesNullsOnRight());
+ b.add(f).nullable(nullable);
+ }
+ }
+ for (RelDataTypeField f : left.rowType.getFieldList()) {
+ final ImmutableIntList source = left.sources.get(f.getIndex());
+ if (sourceSet.add(source)) {
+ sources.add(source);
+ b.add(f);
+ }
+ }
+ for (RelDataTypeField f : right.rowType.getFieldList()) {
+ final ImmutableIntList source = right.sources.get(f.getIndex());
+ if (sourceSet.add(source)) {
+ sources.add(source);
+ b.add(f);
+ }
+ }
+ rowType = b.build();
+ this.sources = ImmutableList.copyOf(sources);
+ this.trivial = left.trivial
+ && right.trivial
+ && (names == null || names.isEmpty());
+ break;
+
+ default:
+ rowType = getValidatedNodeType(from);
+ this.sources = Functions.generate(rowType.getFieldCount(),
+ i -> ImmutableIntList.of(offset + i));
+ this.trivial = true;
+ }
+ }
+
+ private RelDataTypeField field(String name) {
+ return catalogReader.nameMatcher().field(rowType, name);
+ }
+
+ /** Returns the set of field names in the join condition specified by USING
+ * or implicitly by NATURAL, de-duplicated and in order. */
+ private List<String> usingNames(SqlJoin join) {
+ switch (join.getConditionType()) {
+ case USING:
+ final ImmutableList.Builder<String> list = ImmutableList.builder();
+ final Set<String> names = catalogReader.nameMatcher().createSet();
+ for (SqlNode node : (SqlNodeList) join.getCondition()) {
+ final String name = ((SqlIdentifier) node).getSimple();
+ if (names.add(name)) {
+ list.add(name);
+ }
+ }
+ return list.build();
+ case NONE:
+ if (join.isNatural()) {
+ final RelDataType t0 = getValidatedNodeType(join.getLeft());
+ final RelDataType t1 = getValidatedNodeType(join.getRight());
+ return SqlValidatorUtil.deriveNaturalJoinColumnList(
+ catalogReader.nameMatcher(), t0, t1);
+ }
+ }
+ return null;
+ }
+
+ /** Moves fields according to the permutation. */
+ public void permute(List<SqlNode> selectItems,
+ List<Map.Entry<String, RelDataType>> fields) {
+ if (trivial) {
+ return;
+ }
+
+ final List<SqlNode> oldSelectItems = ImmutableList.copyOf(selectItems);
+ selectItems.clear();
+ final List<Map.Entry<String, RelDataType>> oldFields =
+ ImmutableList.copyOf(fields);
+ fields.clear();
+ for (ImmutableIntList source : sources) {
+ final int p0 = source.get(0);
+ Map.Entry<String, RelDataType> field = oldFields.get(p0);
+ final String name = field.getKey();
+ RelDataType type = field.getValue();
+ SqlNode selectItem = oldSelectItems.get(p0);
+ for (int p1 : Util.skip(source)) {
+ final Map.Entry<String, RelDataType> field1 = oldFields.get(p1);
+ final SqlNode selectItem1 = oldSelectItems.get(p1);
+ final RelDataType type1 = field1.getValue();
+ // output is nullable only if both inputs are
+ final boolean nullable = type.isNullable() && type1.isNullable();
+ final RelDataType type2 =
+ SqlTypeUtil.leastRestrictiveForComparison(typeFactory, type,
+ type1);
+ selectItem =
+ SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO,
+ SqlStdOperatorTable.COALESCE.createCall(SqlParserPos.ZERO,
+ maybeCast(selectItem, type, type2),
+ maybeCast(selectItem1, type1, type2)),
+ new SqlIdentifier(name, SqlParserPos.ZERO));
+ type = typeFactory.createTypeWithNullability(type2, nullable);
+ }
+ fields.add(Pair.of(name, type));
+ selectItems.add(selectItem);
+ }
+ }
+ }
+
+ //~ Enums ------------------------------------------------------------------
+
+ /**
+ * Validation status.
+ */
+ public enum Status {
+ /**
+ * Validation has not started for this scope.
+ */
+ UNVALIDATED,
+
+ /**
+ * Validation is in progress for this scope.
+ */
+ IN_PROGRESS,
+
+ /**
+ * Validation has completed (perhaps unsuccessfully).
+ */
+ VALID
+ }
+
+}
+
+// End SqlValidatorImpl.java
diff --git a/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/match/MatchRecognizeValidationTest.scala b/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/match/MatchRecognizeValidationTest.scala
index 2890179..b77a60e 100644
--- a/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/match/MatchRecognizeValidationTest.scala
+++ b/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/match/MatchRecognizeValidationTest.scala
@@ -247,4 +247,25 @@ class MatchRecognizeValidationTest extends TableTestBase {
streamUtils.tableEnv.sqlQuery(sqlQuery).toAppendStream[Row]
}
+
+ @Test
+ def testDistinctAggregationsNotSupported(): Unit = {
+ thrown.expect(classOf[ValidationException])
+
+ val sqlQuery =
+ s"""
+ |SELECT *
+ |FROM Ticker
+ |MATCH_RECOGNIZE (
+ | ORDER BY proctime
+ | MEASURES
+ | COUNT(DISTINCT A.price) AS price
+ | PATTERN (A B)
+ | DEFINE
+ | A AS A.symbol = 'a'
+ |) AS T
+ |""".stripMargin
+
+ streamUtils.tableEnv.sqlQuery(sqlQuery).toAppendStream[Row]
+ }
}
diff --git a/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/runtime/stream/sql/MatchRecognizeITCase.scala b/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/runtime/stream/sql/MatchRecognizeITCase.scala
index ffd1c2b..56087be 100644
--- a/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/runtime/stream/sql/MatchRecognizeITCase.scala
+++ b/flink-libraries/flink-table/src/test/scala/org/apache/flink/table/runtime/stream/sql/MatchRecognizeITCase.scala
@@ -510,7 +510,7 @@ class MatchRecognizeITCase extends StreamingWithStateTestBase {
| MEASURES
| FIRST(id) as startId,
| SUM(A.price) AS sumA,
- | COUNT(DISTINCT D.price) AS countD,
+ | COUNT(D.price) AS countD,
| SUM(D.price) as sumD,
| weightedAvg(price, weight) as wAvg,
| AVG(B.price) AS avgB,