private static Statement parseFormatted(SqlParser sqlParser, ParsingOptions parsingOptions, String sql, Node tree) { try { return sqlParser.createStatement(sql, parsingOptions); } catch (ParsingException e) { throw new AssertionError(format( "failed to parse formatted SQL: %s\nerror: %s\ntree: %s", sql, e.getMessage(), tree)); } }
/** * Consider using {@link #createStatement(String, ParsingOptions)} */ @Deprecated public Statement createStatement(String sql) { return createStatement(sql, new ParsingOptions()); }
static QueryType statementToQueryType(SqlParser parser, String sql) { try { return statementToQueryType(parser.createStatement(sql, new ParsingOptions(AS_DOUBLE /* anything */))); } catch (RuntimeException e) { throw new UnsupportedOperationException(); } }
public PreparedQuery prepareQuery(Session session, String query) throws ParsingException, PrestoException, SemanticException { Statement wrappedStatement = sqlParser.createStatement(query, createParsingOptions(session)); return prepareQuery(session, wrappedStatement); }
private static Statement unwrapExecuteStatement(Statement statement, SqlParser sqlParser, Session session) { if (!(statement instanceof Execute)) { return statement; } String sql = session.getPreparedStatementFromExecute((Execute) statement); return sqlParser.createStatement(sql, createParsingOptions(session)); }
protected String formatSqlText(String sql) { return formatSql(sqlParser.createStatement(sql, createParsingOptions(queryRunner.getDefaultSession())), Optional.empty()); }
@Test(dataProvider = "statements") public void testStatement(String sql, String error) { try { SQL_PARSER.createStatement(sql); fail("Expected parsing to fail"); } catch (ParsingException e) { assertEquals(e.getMessage(), error, "Error message mismatch for query:\n\n" + sql + "\n\n"); } }
private Query parseView(String view, QualifiedObjectName name, Node node) { try { Statement statement = sqlParser.createStatement(view, createParsingOptions(session)); return (Query) statement; } catch (ParsingException e) { throw new SemanticException(VIEW_PARSE_ERROR, node, "Failed parsing stored view '%s': %s", name, e.getMessage()); } }
private Query parseView(String view, QualifiedObjectName name, Node node) { try { return (Query) sqlParser.createStatement(view, createParsingOptions(session)); } catch (ParsingException e) { throw new SemanticException(VIEW_PARSE_ERROR, node, "Failed parsing stored view '%s': %s", name, e.getMessage()); } }
@Test public void testParsingExceptionPositionInfo() { try { SQL_PARSER.createStatement("select *\nfrom x\nwhere from"); fail("expected exception"); } catch (ParsingException e) { assertTrue(e.getMessage().startsWith("line 3:7: mismatched input 'from'")); assertTrue(e.getErrorMessage().startsWith("mismatched input 'from'")); assertEquals(e.getLineNumber(), 3); assertEquals(e.getColumnNumber(), 7); } }
private static void assertStatement(String query, Statement expected) { assertParsed(query, expected, SQL_PARSER.createStatement(query)); assertFormattedSql(SQL_PARSER, expected); }
public static String getFormattedSql(Statement statement, SqlParser sqlParser, Optional<List<Expression>> parameters) { String sql = SqlFormatter.formatSql(statement, parameters); // verify round-trip Statement parsed; try { ParsingOptions parsingOptions = new ParsingOptions(REJECT /* formatted SQL should be unambiguous */); parsed = sqlParser.createStatement(sql, parsingOptions); } catch (ParsingException e) { throw new PrestoException(GENERIC_INTERNAL_ERROR, "Formatted query does not parse: " + statement); } if (!statement.equals(parsed)) { throw new PrestoException(GENERIC_INTERNAL_ERROR, "Query does not round-trip: " + statement); } return sql; } }
public Query shadowQuery(Query query) throws QueryRewriteException, SQLException { if (statementToQueryType(parser, query.getQuery()) == READ) { return query; } if (!query.getPreQueries().isEmpty()) { throw new QueryRewriteException("Cannot rewrite queries that use pre-queries"); } if (!query.getPostQueries().isEmpty()) { throw new QueryRewriteException("Cannot rewrite queries that use post-queries"); } Statement statement = parser.createStatement(query.getQuery(), new ParsingOptions(AS_DOUBLE /* anything */)); try (Connection connection = DriverManager.getConnection(gatewayUrl, usernameOverride.orElse(query.getUsername()), passwordOverride.orElse(query.getPassword()))) { trySetConnectionProperties(query, connection); if (statement instanceof CreateTableAsSelect) { return rewriteCreateTableAsSelect(connection, query, (CreateTableAsSelect) statement); } else if (statement instanceof Insert) { return rewriteInsertQuery(connection, query, (Insert) statement); } } throw new QueryRewriteException("Unsupported query type: " + statement.getClass()); }
public String getGraphvizExplainPlan(String query, ExplainType.Type planType) { QueryExplainer explainer = getQueryExplainer(); return transaction(queryRunner.getTransactionManager(), queryRunner.getAccessControl()) .singleStatement() .execute(queryRunner.getDefaultSession(), session -> { return explainer.getGraphvizPlan(session, sqlParser.createStatement(query, createParsingOptions(session)), planType, emptyList(), WarningCollector.NOOP); }); }
public String getExplainPlan(String query, ExplainType.Type planType) { QueryExplainer explainer = getQueryExplainer(); return transaction(queryRunner.getTransactionManager(), queryRunner.getAccessControl()) .singleStatement() .execute(queryRunner.getDefaultSession(), session -> { return explainer.getPlan(session, sqlParser.createStatement(query, createParsingOptions(session)), planType, emptyList(), WarningCollector.NOOP); }); }
@SuppressWarnings("deprecation") @Test public void testAllowIdentifierAtSign() { SqlParser sqlParser = new SqlParser(new SqlParserOptions().allowIdentifierSymbol(AT_SIGN)); sqlParser.createStatement("select * from foo@bar"); }
@Test public void testAllowIdentifierColon() { SqlParser sqlParser = new SqlParser(new SqlParserOptions().allowIdentifierSymbol(COLON)); sqlParser.createStatement("select * from foo:bar"); }
@Test public void testCreateTableAsSelectDifferentCatalog() throws Exception { handle.execute("CREATE TABLE \"my_test_table2\" (column1 BIGINT, column2 DOUBLE)"); SqlParser parser = new SqlParser(); Query query = new Query(CATALOG, SCHEMA, ImmutableList.of(), "CREATE TABLE public.my_test_table2 AS SELECT 1 column1, 2E0 column2", ImmutableList.of(), null, null, ImmutableMap.of()); QueryRewriter rewriter = new QueryRewriter(parser, URL, QualifiedName.of("other_catalog", "other_schema", "tmp_"), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), 1, new Duration(10, SECONDS)); Query rewrittenQuery = rewriter.shadowQuery(query); assertEquals(rewrittenQuery.getPreQueries().size(), 1); CreateTableAsSelect createTableAs = (CreateTableAsSelect) parser.createStatement(rewrittenQuery.getPreQueries().get(0)); assertEquals(createTableAs.getName().getParts().size(), 3); assertEquals(createTableAs.getName().getPrefix().get(), QualifiedName.of("other_catalog", "other_schema")); assertTrue(createTableAs.getName().getSuffix().startsWith("tmp_")); assertFalse(createTableAs.getName().getSuffix().contains("my_test_table")); }
private static void printStatement(String sql) { println(sql.trim()); println(""); ParsingOptions parsingOptions = new ParsingOptions(AS_DOUBLE /* anything */); Statement statement = SQL_PARSER.createStatement(sql, parsingOptions); println(statement.toString()); println(""); println(SqlFormatter.formatSql(statement, Optional.empty())); println(""); assertFormattedSql(SQL_PARSER, statement); println(repeat("=", 60)); println(""); }
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); }); }