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, 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, 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); }
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); } }
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); }); }
Analyzer.verifyNoAggregateWindowOrGroupingFunctions(metadata.getFunctionRegistry(), column, "GROUP BY clause"); analysis.recordSubqueries(node, analyzeExpression(column, scope)); complexExpressions.add(column);
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); } }
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); }); }
Analyzer.verifyNoAggregateWindowOrGroupingFunctions(metadata.getFunctionRegistry(), column, "GROUP BY clause"); analysis.recordSubqueries(node, analyzeExpression(column, scope)); complexExpressions.add(column);
@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");
@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); }
@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");
@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); }
Analyzer.verifyNoAggregateWindowOrGroupingFunctions(metadata.getFunctionRegistry(), expression, "JOIN clause");