/** * Consider using {@link #createExpression(String, ParsingOptions)} */ @Deprecated public Expression createExpression(String expression) { return createExpression(expression, new ParsingOptions()); }
public static ParsingOptions createParsingOptions(Session session) { return new ParsingOptions(isParseDecimalLiteralsAsDouble(session) ? AS_DOUBLE : AS_DECIMAL); }
/** * Consider using {@link #createStatement(String, ParsingOptions)} */ @Deprecated public Statement createStatement(String sql) { return createStatement(sql, new ParsingOptions()); }
public static void assertFormattedSql(SqlParser sqlParser, Node expected) { ParsingOptions parsingOptions = new ParsingOptions(AS_DOUBLE /* anything */); assertFormattedSql(sqlParser, parsingOptions, expected); }
public PathSpecification createPathSpecification(String expression) { return (PathSpecification) invokeParser("path specification", expression, SqlBaseParser::standalonePathSpecification, 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(); } }
private static Map<String, String> parsePreparedStatementsHeaders(HttpServletRequest servletRequest) { ImmutableMap.Builder<String, String> preparedStatements = ImmutableMap.builder(); for (String header : splitSessionHeader(servletRequest.getHeaders(PRESTO_PREPARED_STATEMENT))) { List<String> nameValue = Splitter.on('=').limit(2).trimResults().splitToList(header); assertRequest(nameValue.size() == 2, "Invalid %s header", PRESTO_PREPARED_STATEMENT); String statementName; String sqlString; try { statementName = urlDecode(nameValue.get(0)); sqlString = urlDecode(nameValue.get(1)); } catch (IllegalArgumentException e) { throw badRequest(format("Invalid %s header: %s", PRESTO_PREPARED_STATEMENT, e.getMessage())); } // Validate statement SqlParser sqlParser = new SqlParser(); try { sqlParser.createStatement(sqlString, new ParsingOptions(AS_DOUBLE /* anything */)); } catch (ParsingException e) { throw badRequest(format("Invalid %s header: %s", PRESTO_PREPARED_STATEMENT, e.getMessage())); } preparedStatements.put(statementName, sqlString); } return preparedStatements.build(); }
private static void assertSqlFormatter(String expression, String formatted) { Expression originalExpression = SQL_PARSER.createExpression(expression, new ParsingOptions()); String real = SqlFormatter.formatSql(originalExpression, Optional.empty()); assertEquals(real, formatted); }
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()); }
private static void assertEquivalent(@Language("SQL") String left, @Language("SQL") String right) { ParsingOptions parsingOptions = new ParsingOptions(AS_DOUBLE /* anything */); Expression leftExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(left, parsingOptions)); Expression rightExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(right, parsingOptions)); Set<Symbol> symbols = extractUnique(ImmutableList.of(leftExpression, rightExpression)); TypeProvider types = TypeProvider.copyOf(symbols.stream() .collect(toMap(identity(), TestExpressionEquivalence::generateType))); assertTrue( EQUIVALENCE.areExpressionsEquivalent(TEST_SESSION, leftExpression, rightExpression, types), String.format("Expected (%s) and (%s) to be equivalent", left, right)); assertTrue( EQUIVALENCE.areExpressionsEquivalent(TEST_SESSION, rightExpression, leftExpression, types), String.format("Expected (%s) and (%s) to be equivalent", right, left)); }
public static PlanMatchPattern spatialLeftJoin(String expectedFilter, PlanMatchPattern left, PlanMatchPattern right) { return node(SpatialJoinNode.class, left, right).with( new SpatialJoinMatcher(SpatialJoinNode.Type.LEFT, rewriteIdentifiersToSymbolReferences(new SqlParser().createExpression(expectedFilter, new ParsingOptions())), Optional.empty())); }
private static void assertNotEquivalent(@Language("SQL") String left, @Language("SQL") String right) { ParsingOptions parsingOptions = new ParsingOptions(AS_DOUBLE /* anything */); Expression leftExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(left, parsingOptions)); Expression rightExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(right, parsingOptions)); Set<Symbol> symbols = extractUnique(ImmutableList.of(leftExpression, rightExpression)); TypeProvider types = TypeProvider.copyOf(symbols.stream() .collect(toMap(identity(), TestExpressionEquivalence::generateType))); assertFalse( EQUIVALENCE.areExpressionsEquivalent(TEST_SESSION, leftExpression, rightExpression, types), String.format("Expected (%s) and (%s) to not be equivalent", left, right)); assertFalse( EQUIVALENCE.areExpressionsEquivalent(TEST_SESSION, rightExpression, leftExpression, types), String.format("Expected (%s) and (%s) to not be equivalent", right, left)); }
public static PlanMatchPattern spatialJoin(String expectedFilter, Optional<String> kdbTree, PlanMatchPattern left, PlanMatchPattern right) { return node(SpatialJoinNode.class, left, right).with( new SpatialJoinMatcher(SpatialJoinNode.Type.INNER, rewriteIdentifiersToSymbolReferences(new SqlParser().createExpression(expectedFilter, new ParsingOptions())), kdbTree)); }
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(""); }
SQL_PARSER.createStatement("SET PATH ", new ParsingOptions()); fail();
public synchronized static Expression parseExpression(String query) { return sqlParser.createExpression(checkNotNull(query, "query is required"), new ParsingOptions(ParsingOptions.DecimalLiteralTreatment.AS_DOUBLE)); } }
public synchronized static Statement parseSql(String query) { return sqlParser.createStatement(checkNotNull(query, "query is required"), new ParsingOptions(ParsingOptions.DecimalLiteralTreatment.AS_DOUBLE)); }
private QueryExecution getSingleQueryExecution(String query, List<CustomDataSource> type) { char seperator = dbSeparator(type.get(0).type); StringBuilder builder = new StringBuilder(); Statement statement = sqlParser.createStatement(query, new ParsingOptions()); try { new RakamSqlFormatter.Formatter(builder, qualifiedName -> { String schema = qualifiedName.getPrefix().get().toString(); CustomDataSource customDataSource1 = type.stream() .filter(e -> e.schemaName.equals(schema)).findAny() .orElseThrow(() -> new RakamException("Cross database operations are not supported.", BAD_REQUEST)); return SupportedCustomDatabase.getAdapter(customDataSource1.type).getTableMapper() .apply(customDataSource1.options, qualifiedName.getSuffix()); }, seperator) { }.process(statement, 1); } catch (UnsupportedOperationException e) { return null; } String sqlQuery = builder.toString(); return new JDBCQueryExecution(() -> SupportedCustomDatabase.getAdapter(type.get(0).type).getDataSource().openConnection(type.get(0).options), sqlQuery, false, Optional.empty(), false); }
@Test public void testName() throws Exception { String sql = "select selami:timestamp, melami:varchar from deneme where ali:timestamp is not null and veli is null group by demo"; SqlParserOptions options = new SqlParserOptions().allowIdentifierSymbol(IdentifierSymbol.COLON); Statement statement = new SqlParser(options).createStatement(sql, new ParsingOptions(ParsingOptions.DecimalLiteralTreatment.AS_DOUBLE)); String s = RakamSqlFormatter.formatSql(statement, name -> String.format("(SELECT * FROM events WHERE collection_name = '%s')", name.toString()), name -> "\"$data\"['" + name + "']", '"'); System.out.println(s); } }