Refine search![Refine arrow](//d16xvuom8mr9m8.cloudfront.net/code/public/images/refine-arrow.226bef887e7b1c430d6d498717d9d561.svg)
protected String formatSqlText(String sql) { return formatSql(sqlParser.createStatement(sql, createParsingOptions(queryRunner.getDefaultSession())), Optional.empty()); }
private void parsePath() { checkState(rawPath.isPresent(), "rawPath must be present to parse"); SqlParser parser = new SqlParser(); List<PathElement> pathSpecification = parser.createPathSpecification(rawPath.get()).getPath(); this.parsedPath = pathSpecification.stream() .map(pathElement -> new SqlPathElement(pathElement.getCatalog(), pathElement.getSchema())) .collect(toImmutableList()); }
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 sql) { SqlParser parser = new SqlParser(); return rewriteIdentifiersToSymbolReferences(parser.createExpression(sql)); }
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(); }
@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")); }
public ResponseQuery explain(@ApiParam(value = "query", description = "Query") String query) { try { Query statement = (Query) sqlParser.createStatement(query, new ParsingOptions(ParsingOptions.DecimalLiteralTreatment.AS_DOUBLE)); Map<String, NodeLocation> map = statement.getWith().map(with -> { ImmutableMap.Builder<String, NodeLocation> builder = ImmutableMap.builder(); with.getQueries().stream() .forEach(withQuery -> builder.put(withQuery.getName().getValue(), withQuery.getQuery().getLocation().orElse(null))); return builder.build(); }).orElse(null); statement.getQueryBody().getLocation().orElse(null), ImmutableList.of(), ImmutableList.of(), statement.getLimit().map(l -> Long.parseLong(l)).orElse(null)); } catch (Throwable e) {
case PostgresqlDataSource.NAME: case MysqlDataSource.NAME: schema = Optional.empty(); break; default: schema = Optional.empty(); break; StringBuilder builder = new StringBuilder(); new RakamSqlFormatter.Formatter(builder, qualifiedName -> { String prefix = qualifiedName.getPrefix().get().getPrefix().get().toString(); if (!prefix.equals("external")) { hasOutsideReference.set(true); }, seperator).process(sqlParser.createStatement(query, new ParsingOptions(ParsingOptions.DecimalLiteralTreatment.AS_DOUBLE)), 1);
@Test public void testSetPath() new SetPath(new PathSpecification(Optional.empty(), ImmutableList.of( new PathElement(Optional.of(new Identifier("iLikeToEat")), new Identifier("apples")), new PathElement(Optional.empty(), new Identifier("andBananas")))))); new SetPath(new PathSpecification(Optional.empty(), ImmutableList.of( new PathElement(Optional.of(new Identifier("schemas,with")), new Identifier("grammar.in")), new PathElement(Optional.empty(), new Identifier("their!names")))))); new SetPath(new PathSpecification(Optional.empty(), ImmutableList.of( new PathElement(Optional.empty(), new Identifier("")))))); new SetPath(new PathSpecification(Optional.empty(), ImmutableList.of( new PathElement(Optional.empty(), new Identifier("dummyValue")))))); fail(); SQL_PARSER.createStatement("SET PATH ", new ParsingOptions()); fail();
.collect(Collectors.toList()); predicate = Optional.ofNullable(item.getFilter()) .map(value -> new SqlParser().createExpression(item.getFilter())) .map(expression -> expressionCompiler.generate(expression, collect)) .orElse(null); }).collect(Collectors.toList()); } else { collect1 = ImmutableList.of(new CollectionFilter(null, null));
@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 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); }
public List<Driver> createDrivers(Session session, @Language("SQL") String sql, OutputFactory outputFactory, TaskContext taskContext) Statement statement = sqlParser.createStatement(sql); dataDefinitionTask, featuresConfig.isExperimentalSyntaxEnabled()); Analyzer analyzer = new Analyzer(session, metadata, sqlParser, accessControl, Optional.of(queryExplainer), featuresConfig.isExperimentalSyntaxEnabled()); long sequenceId = 0; for (TableScanNode tableScan : findTableScanNodes(subplan.getFragment().getRoot())) { TableLayoutHandle layout = tableScan.getLayout().get(); return ImmutableList.copyOf(drivers);
private LocalQueryRunner(Session defaultSession, FeaturesConfig featuresConfig, NodeSpillConfig nodeSpillConfig, boolean withInitialTransaction, boolean alwaysRevokeMemory, int nodeCountForStats) checkArgument(!defaultSession.getTransactionId().isPresent() || !withInitialTransaction, "Already in transaction"); finalizerService.start(); this.sqlParser = new SqlParser(); this.nodeManager = new InMemoryNodeManager(); this.typeRegistry = new TypeRegistry(); withInitialTransaction ? Optional.of(transactionManager.beginTransaction(false)) : defaultSession.getTransactionId(), defaultSession.isClientTransactionSupport(), defaultSession.getIdentity(),
@JsonIgnore public synchronized Optional<Expression> getExpression() { try { return filterExpression.map(value -> parser.createExpression(value)); } catch (Exception e) { throw new RakamException("Unable to parse filter expression: " + filterExpression.get(), HttpResponseStatus.BAD_REQUEST); } } }
@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"); } }
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 void validateQuery() { Statement query; synchronized (SQL_PARSER) { query = SQL_PARSER.createStatement(this.query, new ParsingOptions(ParsingOptions.DecimalLiteralTreatment.AS_DOUBLE)); } checkState(query instanceof Query, "Expression is not query"); checkState((!((Query) query).getLimit().isPresent()), "The query of materialized view can't contain LIMIT statement"); // QueryBody queryBody = ((Query) query).getQueryBody(); // if (queryBody instanceof QuerySpecification) { // List<SelectItem> selectItems = ((QuerySpecification) queryBody).getSelect().getSelectItems(); // if (selectItems.stream().anyMatch(e -> e instanceof AllColumns)) { // throw new RakamException("Wildcard in select items is not supported in materialized views.", BAD_REQUEST); // } // // for (SelectItem selectItem : selectItems) { // SingleColumn selectColumn = (SingleColumn) selectItem; // if (!selectColumn.getAlias().isPresent() && !(selectColumn.getExpression() instanceof Identifier) // && !(selectColumn.getExpression() instanceof DereferenceExpression)) { // throw new RakamException(format("Column '%s' must have alias", selectColumn.getExpression().toString()), BAD_REQUEST); // } // } // } }
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 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)); }