private static boolean reserved(String name) { try { return !(PARSER.createExpression(name) instanceof Identifier); } catch (ParsingException ignored) { return true; } } }
private static boolean reserved(String name) { try { return !(PARSER.createExpression(name) instanceof Identifier); } catch (ParsingException ignored) { return true; } } }
@Override public FunctionCall deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return (FunctionCall) rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(jsonParser.readValueAs(String.class))); } }
/** * Consider using {@link #createExpression(String, ParsingOptions)} */ @Deprecated public Expression createExpression(String expression) { return createExpression(expression, new ParsingOptions()); }
@Override public Expression deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(jsonParser.readValueAs(String.class))); } }
/** * Consider using {@link #createExpression(String, ParsingOptions)} */ @Deprecated public Expression createExpression(String expression) { return createExpression(expression, new ParsingOptions()); }
@Override public Expression deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(jsonParser.readValueAs(String.class))); } }
@Override public FunctionCall deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return (FunctionCall) rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(jsonParser.readValueAs(String.class))); } }
@Test public void testPossibleExponentialBacktracking() { SQL_PARSER.createExpression("(((((((((((((((((((((((((((true)))))))))))))))))))))))))))"); }
private static void assertRoundTrip(String expression) { ParsingOptions parsingOptions = createParsingOptions(TEST_SESSION); assertEquals(SQL_PARSER.createExpression(expression, parsingOptions), SQL_PARSER.createExpression(formatExpression(SQL_PARSER.createExpression(expression, parsingOptions), Optional.empty()), parsingOptions)); }
private static void assertRoundTrip(String expression) { ParsingOptions parsingOptions = createParsingOptions(TEST_SESSION); assertEquals(SQL_PARSER.createExpression(expression, parsingOptions), SQL_PARSER.createExpression(formatExpression(SQL_PARSER.createExpression(expression, parsingOptions), Optional.empty()), parsingOptions)); }
private Expression expression(String sqlExpression) { return rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(sqlExpression)); } }
private Expression expression(String sqlExpression) { return rewriteIdentifiersToSymbolReferences(sqlParser.createExpression(sqlExpression)); } }
private Expression expression(String sql) { return rewriteIdentifiersToSymbolReferences(parser.createExpression(sql)); }
private Expression expression(String sql) { SqlParser parser = new SqlParser(); return rewriteIdentifiersToSymbolReferences(parser.createExpression(sql)); }
private static void assertSimplifies(String expression, String expected) { Expression actualExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expression)); Expression expectedExpression = rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expected)); Expression rewritten = rewrite(actualExpression, TEST_SESSION, new SymbolAllocator(booleanSymbolTypeMapFor(actualExpression)), METADATA, LITERAL_ENCODER, SQL_PARSER); assertEquals( normalize(rewritten), normalize(expectedExpression)); }
public static PlanMatchPattern join(JoinNode.Type joinType, List<ExpectedValueProvider<JoinNode.EquiJoinClause>> expectedEquiCriteria, Optional<String> expectedFilter, Optional<JoinNode.DistributionType> expectedDistributionType, PlanMatchPattern left, PlanMatchPattern right) { return node(JoinNode.class, left, right).with( new JoinMatcher( joinType, expectedEquiCriteria, expectedFilter.map(predicate -> rewriteIdentifiersToSymbolReferences(new SqlParser().createExpression(predicate))), expectedDistributionType)); }
private static void assertOptimizedMatches(@Language("SQL") String actual, @Language("SQL") String expected) { // replaces FunctionCalls to FailureFunction by fail() Object actualOptimized = optimize(actual); if (actualOptimized instanceof Expression) { actualOptimized = ExpressionTreeRewriter.rewriteWith(new FailedFunctionRewriter(), (Expression) actualOptimized); } assertEquals( actualOptimized, rewriteIdentifiersToSymbolReferences(SQL_PARSER.createExpression(expected))); }
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)); }
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)); }