@Override protected String visitExists(ExistsPredicate node, Void context) { return "(EXISTS " + formatSql(node.getSubquery(), parameters) + ")"; }
@Override protected String visitArrayConstructor(ArrayConstructor node, Void context) { ImmutableList.Builder<String> valueStrings = ImmutableList.builder(); for (Expression value : node.getValues()) { valueStrings.add(formatSql(value, parameters)); } return "ARRAY[" + Joiner.on(",").join(valueStrings.build()) + "]"; }
@Override protected String visitSubqueryExpression(SubqueryExpression node, Void context) { return "(" + formatSql(node.getQuery(), parameters) + ")"; }
private static String dropTableSql(QualifiedName table) { return formatSql(new DropTable(table, true), Optional.empty()); }
@Override protected String visitArrayConstructor(ArrayConstructor node, Void context) { ImmutableList.Builder<String> valueStrings = ImmutableList.builder(); for (Expression value : node.getValues()) { valueStrings.add(formatSql(value, parameters)); } return "ARRAY[" + Joiner.on(",").join(valueStrings.build()) + "]"; }
@Override protected String visitSubqueryExpression(SubqueryExpression node, Void context) { return "(" + formatSql(node.getQuery(), parameters) + ")"; }
@Override protected String visitExists(ExistsPredicate node, Void context) { return "(EXISTS " + formatSql(node.getSubquery(), parameters) + ")"; }
protected String formatSqlText(String sql) { return formatSql(sqlParser.createStatement(sql, createParsingOptions(queryRunner.getDefaultSession())), Optional.empty()); }
public static void assertFormattedSql(SqlParser sqlParser, ParsingOptions parsingOptions, Node expected) { String formatted = formatSql(expected, Optional.empty()); // verify round-trip of formatting already-formatted SQL Statement actual = parseFormatted(sqlParser, parsingOptions, formatted, expected); assertEquals(formatSql(actual, Optional.empty()), formatted); // compare parsed tree with parsed tree of formatted SQL if (!actual.equals(expected)) { // simplify finding the non-equal part of the tree assertListEquals(linearizeTree(actual), linearizeTree(expected)); } assertEquals(actual, expected); }
public static void assertFormattedSql(SqlParser sqlParser, ParsingOptions parsingOptions, Node expected) { String formatted = formatSql(expected, Optional.empty()); // verify round-trip of formatting already-formatted SQL Statement actual = parseFormatted(sqlParser, parsingOptions, formatted, expected); assertEquals(formatSql(actual, Optional.empty()), formatted); // compare parsed tree with parsed tree of formatted SQL if (!actual.equals(expected)) { // simplify finding the non-equal part of the tree assertListEquals(linearizeTree(actual), linearizeTree(expected)); } assertEquals(actual, expected); }
private String checksumSql(List<Column> columns, QualifiedName table) throws QueryRewriteException { if (columns.isEmpty()) { throw new QueryRewriteException("Table " + table + " has no columns"); } ImmutableList.Builder<SelectItem> selectItems = ImmutableList.builder(); for (Column column : columns) { Expression expression = new Identifier(column.getName()); if (column.isApproximateType()) { expression = new FunctionCall(QualifiedName.of("round"), ImmutableList.of(expression, new LongLiteral(Integer.toString(doublePrecision)))); } selectItems.add(new SingleColumn(new FunctionCall(QualifiedName.of("checksum"), ImmutableList.of(expression)))); } Select select = new Select(false, selectItems.build()); return formatSql(new QuerySpecification(select, Optional.of(new Table(table)), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty()), Optional.empty()); }
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); }
private Query rewriteInsertQuery(Connection connection, Query query, Insert statement) throws SQLException, QueryRewriteException { QualifiedName temporaryTableName = generateTemporaryTableName(statement.getTarget()); Statement createTemporaryTable = new CreateTable(temporaryTableName, ImmutableList.of(new LikeClause(statement.getTarget(), Optional.of(INCLUDING))), true, ImmutableList.of(), Optional.empty()); String createTemporaryTableSql = formatSql(createTemporaryTable, Optional.empty()); String insertSql = formatSql(new Insert(temporaryTableName, statement.getColumns(), statement.getQuery()), Optional.empty()); String checksumSql = checksumSql(getColumnsForTable(connection, query.getCatalog(), query.getSchema(), statement.getTarget().toString()), temporaryTableName); String dropTableSql = dropTableSql(temporaryTableName); return new Query(query.getCatalog(), query.getSchema(), ImmutableList.of(createTemporaryTableSql, insertSql), checksumSql, ImmutableList.of(dropTableSql), query.getUsername(), query.getPassword(), query.getSessionProperties()); }
TimeLimiter limiter = SimpleTimeLimiter.create(executor); java.sql.Statement limitedStatement = limiter.newProxy(jdbcStatement, java.sql.Statement.class, timeout.toMillis(), TimeUnit.MILLISECONDS); try (ResultSet resultSet = limitedStatement.executeQuery(formatSql(zeroRowsQuery, Optional.empty()))) { ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 1; i <= metaData.getColumnCount(); i++) {
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; } }