private Scope createAndAssignScope(Node node, Optional<Scope> parentScope, RelationType relationType) { Scope scope = scopeBuilder(parentScope) .withRelationType(RelationId.of(node), relationType) .build(); analysis.setScope(node, scope); return scope; }
private Scope computeAndAssignOrderByScope(OrderBy node, Scope sourceScope, Scope outputScope) { // ORDER BY should "see" both output and FROM fields during initial analysis and non-aggregation query planning Scope orderByScope = Scope.builder() .withParent(sourceScope) .withRelationType(outputScope.getRelationId(), outputScope.getRelationType()) .build(); analysis.setScope(node, orderByScope); return orderByScope; }
public static Map<NodeRef<Expression>, Type> getExpressionTypes( Session session, Metadata metadata, SqlParser sqlParser, TypeProvider types, Iterable<Expression> expressions, List<Expression> parameters, WarningCollector warningCollector, boolean isDescribe) { return analyzeExpressionsWithSymbols(session, metadata, sqlParser, types, expressions, parameters, warningCollector, isDescribe).getExpressionTypes(); }
@Override protected Scope visitProperty(Property node, Optional<Scope> scope) { // Property value expressions must be constant createConstantAnalyzer(metadata, session, analysis.getParameters(), WarningCollector.NOOP, analysis.isDescribe()) .analyze(node.getValue(), createScope(scope)); return createAndAssignScope(node, scope); }
public static FieldId from(ResolvedField field) { requireNonNull(field, "field is null"); Scope sourceScope = field.getScope(); RelationType relationType = sourceScope.getRelationType(); return new FieldId(sourceScope.getRelationId(), relationType.indexOf(field.getField())); }
private void analyze(Expression expression) { Visitor visitor = new Visitor(); if (!visitor.process(expression, null)) { throw new SemanticException(MUST_BE_AGGREGATE_OR_GROUP_BY, expression, "'%s' must be an aggregate expression or appear in GROUP BY clause", expression); } }
@Override public Type visitFieldReference(FieldReference node, StackableAstVisitorContext<Context> context) { Field field = baseScope.getRelationType().getFieldByIndex(node.getFieldIndex()); return handleResolvedField(node, new FieldId(baseScope.getRelationId(), node.getFieldIndex()), field, context); }
@Override protected Scope visitLateral(Lateral node, Optional<Scope> scope) { StatementAnalyzer analyzer = new StatementAnalyzer(analysis, metadata, sqlParser, accessControl, session, WarningCollector.NOOP); Scope queryScope = analyzer.analyze(node.getQuery(), scope); return createAndAssignScope(node, scope, queryScope.getRelationType()); }
public static ExpressionAnalysis analyzeExpressionsWithSymbols( Session session, Metadata metadata, SqlParser sqlParser, TypeProvider types, Iterable<Expression> expressions, List<Expression> parameters, WarningCollector warningCollector, boolean isDescribe) { return analyzeExpressions(session, metadata, sqlParser, new RelationType(), types, expressions, parameters, warningCollector, isDescribe); }
private Scope createAndAssignScope(Node node, Optional<Scope> parentScope, Field... fields) { return createAndAssignScope(node, parentScope, new RelationType(fields)); }
public static Map<NodeRef<Expression>, Type> getExpressionTypesFromInput( Session session, Metadata metadata, SqlParser sqlParser, Map<Integer, Type> types, Iterable<Expression> expressions, List<Expression> parameters, WarningCollector warningCollector) { return analyzeExpressionsWithInputs(session, metadata, sqlParser, types, expressions, parameters, warningCollector).getExpressionTypes(); }
private Type handleResolvedField(Expression node, ResolvedField resolvedField, StackableAstVisitorContext<Context> context) { return handleResolvedField(node, FieldId.from(resolvedField), resolvedField.getField(), context); }
private ResolvedField asResolvedField(Field field, int fieldIndexOffset, boolean local) { int relationFieldIndex = relation.indexOf(field); int hierarchyFieldIndex = relation.indexOf(field) + fieldIndexOffset; return new ResolvedField(this, field, hierarchyFieldIndex, relationFieldIndex, local); }
private Scope createScope(Optional<Scope> parentScope) { return scopeBuilder(parentScope).build(); }
public RelationType getOutputDescriptor(Node node) { return getScope(node).getRelationType(); }
@Override protected Void visitIdentifier(Identifier node, Void context) { throw new SemanticException(EXPRESSION_NOT_CONSTANT, expression, "Constant expression cannot contain column references"); }
public Scope build() { return new Scope(parent, queryBoundary, relationId, relationType, namedQueries); } }
@Override protected Scope visitTableSubquery(TableSubquery node, Optional<Scope> scope) { StatementAnalyzer analyzer = new StatementAnalyzer(analysis, metadata, sqlParser, accessControl, session, WarningCollector.NOOP); Scope queryScope = analyzer.analyze(node.getQuery(), scope); return createAndAssignScope(node, scope, queryScope.getRelationType()); }
private Scope createAndAssignScope(Node node, Optional<Scope> parentScope, List<Field> fields) { return createAndAssignScope(node, parentScope, new RelationType(fields)); }