private Analysis analyzeStatement(Statement statement, Session session, Metadata metadata, AccessControl accessControl, List<Expression> parameters, WarningCollector warningCollector) { Analyzer analyzer = new Analyzer(session, metadata, sqlParser, accessControl, Optional.empty(), parameters, warningCollector); return analyzer.analyze(statement); } }
public void analyzeWhere(Node node, Scope scope, Expression predicate) { Analyzer.verifyNoAggregateWindowOrGroupingFunctions(metadata.getFunctionRegistry(), predicate, "WHERE clause"); ExpressionAnalysis expressionAnalysis = analyzeExpression(predicate, scope); analysis.recordSubqueries(node, expressionAnalysis); Type predicateType = expressionAnalysis.getType(predicate); if (!predicateType.equals(BOOLEAN)) { if (!predicateType.equals(UNKNOWN)) { throw new SemanticException(TYPE_MISMATCH, predicate, "WHERE clause must evaluate to a boolean: actual type %s", predicateType); } // coerce null to boolean analysis.addCoercion(predicate, BOOLEAN, false); } analysis.setWhere(node, predicate); }
public Analysis analyze(Statement statement) { return analyze(statement, false); }
private static Analyzer createAnalyzer(Session session, Metadata metadata) { return new Analyzer( session, metadata, SQL_PARSER, new AllowAllAccessControl(), Optional.empty(), emptyList(), WarningCollector.NOOP); }
public void analyzeWhere(Node node, RelationType tupleDescriptor, AnalysisContext context, Expression predicate) { Analyzer.verifyNoAggregatesOrWindowFunctions(metadata, predicate, "WHERE"); ExpressionAnalysis expressionAnalysis = analyzeExpression(predicate, tupleDescriptor, context); analysis.recordSubqueries(node, expressionAnalysis); Type predicateType = expressionAnalysis.getType(predicate); if (!predicateType.equals(BOOLEAN)) { if (!predicateType.equals(UNKNOWN)) { throw new SemanticException(TYPE_MISMATCH, predicate, "WHERE clause must evaluate to a boolean: actual type %s", predicateType); } // coerce null to boolean analysis.addCoercion(predicate, BOOLEAN); } analysis.setWhere(node, predicate); }
private void analyze(Session clientSession, @Language("SQL") String query) { transaction(transactionManager, accessControl) .singleStatement() .readUncommitted() .readOnly() .execute(clientSession, session -> { Analyzer analyzer = createAnalyzer(session, metadata); Statement statement = SQL_PARSER.createStatement(query); analyzer.analyze(statement); }); }
private static Analyzer createAnalyzer(Session session, Metadata metadata, boolean experimentalSyntaxEnabled) { return new Analyzer( session, metadata, SQL_PARSER, new AllowAllAccessControl(), Optional.empty(), experimentalSyntaxEnabled); }
Analyzer.verifyNoAggregatesOrWindowFunctions(metadata, groupByExpression.getExpression(), "GROUP BY"); type = analysis.getType(groupByExpression.getExpression());
private void analyzeWithoutExperimentalSyntax(@Language("SQL") String query) { transaction(transactionManager) .singleStatement() .readUncommitted() .readOnly() .execute(CLIENT_SESSION, session -> { Analyzer analyzer = createAnalyzer(session, metadata, false); Statement statement = SQL_PARSER.createStatement(query); analyzer.analyze(statement); }); }
Analyzer.verifyNoAggregateWindowOrGroupingFunctions(metadata.getFunctionRegistry(), column, "GROUP BY clause"); analysis.recordSubqueries(node, analyzeExpression(column, scope)); complexExpressions.add(column);
analyzer.analyze(expression, output, context); Analyzer.verifyNoAggregatesOrWindowFunctions(metadata, expression, "JOIN");
@Override protected Node visitDescribeInput(DescribeInput node, Void context) throws SemanticException { String sqlString = session.getPreparedStatement(node.getName().getValue()); Statement statement = parser.createStatement(sqlString, createParsingOptions(session)); // create analysis for the query we are describing. Analyzer analyzer = new Analyzer(session, metadata, parser, accessControl, queryExplainer, parameters, warningCollector); Analysis analysis = analyzer.analyze(statement, true); // get all parameters in query List<Parameter> parameters = getParameters(statement); // return the positions and types of all parameters Row[] rows = parameters.stream().map(parameter -> createDescribeInputRow(parameter, analysis)).toArray(Row[]::new); Optional<String> limit = Optional.empty(); if (rows.length == 0) { rows = new Row[] {row(new NullLiteral(), new NullLiteral())}; limit = Optional.of("0"); } return simpleQuery( selectList(identifier("Position"), identifier("Type")), aliased( values(rows), "Parameter Input", ImmutableList.of("Position", "Type")), Optional.empty(), Optional.empty(), Optional.empty(), Optional.of(ordering(ascending("Position"))), limit); }
private void analyze(Session clientSession, @Language("SQL") String query) { transaction(transactionManager) .singleStatement() .readUncommitted() .readOnly() .execute(clientSession, session -> { Analyzer analyzer = createAnalyzer(session, metadata, true); Statement statement = SQL_PARSER.createStatement(query); analyzer.analyze(statement); }); }
@Override protected Type visitLambdaExpression(LambdaExpression node, StackableAstVisitorContext<Context> context) verifyNoAggregateWindowOrGroupingFunctions(functionRegistry, node.getBody(), "Lambda expression"); if (!context.getContext().isExpectingLambda()) { throw new SemanticException(STANDALONE_LAMBDA, node, "Lambda expression should always be used inside a function");
Analyzer.verifyNoAggregateWindowOrGroupingFunctions(metadata.getFunctionRegistry(), expression, "JOIN clause");
public Plan createPlan(Session session, @Language("SQL") String sql, List<PlanOptimizer> optimizers, LogicalPlanner.Stage stage, WarningCollector warningCollector) { PreparedQuery preparedQuery = new QueryPreparer(sqlParser).prepareQuery(session, sql); assertFormattedSql(sqlParser, createParsingOptions(session), preparedQuery.getStatement()); PlanNodeIdAllocator idAllocator = new PlanNodeIdAllocator(); QueryExplainer queryExplainer = new QueryExplainer( optimizers, planFragmenter, metadata, accessControl, sqlParser, statsCalculator, costCalculator, dataDefinitionTask); Analyzer analyzer = new Analyzer(session, metadata, sqlParser, accessControl, Optional.of(queryExplainer), preparedQuery.getParameters(), warningCollector); LogicalPlanner logicalPlanner = new LogicalPlanner(session, optimizers, new PlanSanityChecker(true), idAllocator, metadata, sqlParser, statsCalculator, costCalculator, warningCollector); Analysis analysis = analyzer.analyze(preparedQuery.getStatement()); return logicalPlanner.plan(analysis, stage); }