Java 类com.facebook.presto.sql.tree.Delete 实例源码

@Override
protected Void visitDelete(Delete node, Integer indent)
{
    builder.append("DELETE FROM ")
            .append(node.getTable().getName());

    if (node.getWhere().isPresent()) {
        builder.append(" WHERE ")
                .append(formatExpression(node.getWhere().get(), parameters, indent));
    }

    return null;
}

@Override
public int executeUpdate(String sql) throws SQLException {
    //System.out.println("QUERY: ["+sql+"]");
    sql = sql.replaceAll("\r", " ").replaceAll("\n", " ").trim();
    // custom stuff to support UPDATE statements since Presto does not parse it
    if(sql.toLowerCase().startsWith("update")){
        return updateState.execute(sql);
    }

    com.facebook.presto.sql.tree.Statement statement = parser.createStatement(sql);
    if(statement instanceof Query) throw new SQLException("A regular query cannot be executed as an Update");
    if(statement instanceof Insert){
        //if(connection.getSchema() == null) throw new SQLException("No active index set for this driver. Pleas specify an active index or alias by executing 'USE <index/alias>' first");
        return updateState.execute(sql, (Insert)statement, connection.getSchema());
    }else if(statement instanceof Delete){
        if(connection.getSchema() == null) throw new SQLException("No active index set for this driver. Pleas specify an active index or alias by executing 'USE <index/alias>' first");
        return updateState.execute(sql, (Delete)statement, connection.getSchema());
    }else if(statement instanceof CreateTable){
        return updateState.execute(sql, (CreateTable)statement, connection.getSchema());
    }else if(statement instanceof CreateTableAsSelect){
        return updateState.execute(sql, (CreateTableAsSelect)statement, connection.getSchema());
    }else if(statement instanceof CreateView){
        return updateState.execute(sql, (CreateView)statement, connection.getSchema());
    }else if(statement instanceof Use){
        connection.setSchema( ((Use)statement).getSchema());
        //connection.getTypeMap(); // updates the type mappings found in properties
        return 0;
    }else if(statement instanceof DropTable){
        return updateState.execute(sql, (DropTable)statement);
    }else if(statement instanceof DropView){
        return updateState.execute(sql, (DropView)statement);
    }throw new SQLFeatureNotSupportedException("Unable to parse provided update sql");
}

/**
 * Executes the {@link BulkRequest} being hold by this state.
 * @return an integer indicator for each executed request: Statement.SUCCESS_NO_INFO for success, 
 * else Statement.EXECUTE_FAILED)
 */
public int[] executeBulk(){
    int[] result = new int[bulkList.size()];
    SqlParser parser = new SqlParser();
    for(int i=0; i<bulkList.size(); i++) try{
        String sql = bulkList.get(i);
        com.facebook.presto.sql.tree.Statement st = parser.createStatement(sql);
        if(st instanceof DropTable){
            this.execute(sql, (DropTable)st);
        }else if(st instanceof DropView){
            this.execute(sql, (DropView)st);
        }else if(st instanceof CreateTable){
            this.execute(sql, (CreateTable)st, this.statement.getConnection().getSchema());
        }else if(st instanceof CreateTableAsSelect){
            this.execute(sql, (CreateTableAsSelect)st, this.statement.getConnection().getSchema());
        }else if(st instanceof CreateView){
            this.execute(sql, (CreateView)st, this.statement.getConnection().getSchema());
        }else if(st instanceof Delete){
            this.execute(sql, (Delete)st, this.statement.getConnection().getSchema());
        }else  if(st instanceof Insert){
            this.execute(sql, (Insert)st, this.statement.getConnection().getSchema());
        }
        result[i]= Statement.SUCCESS_NO_INFO;
    }catch (Exception e){
        result[i] = Statement.EXECUTE_FAILED;
    }
    this.clearBulk();
    return result;
}

@Override
protected RelationType visitDelete(Delete node, AnalysisContext context)
{
    Table table = node.getTable();
    QualifiedObjectName tableName = createQualifiedObjectName(session, table, table.getName());
    if (metadata.getView(session, tableName).isPresent()) {
        throw new SemanticException(NOT_SUPPORTED, node, "Deleting from views is not supported");
    }

    analysis.setUpdateType("DELETE");

    analysis.setDelete(node);

    // Analyzer checks for select permissions but DELETE has a separate permission, so disable access checks
    // TODO: we shouldn't need to create a new analyzer. The access control should be carried in the context object
    StatementAnalyzer analyzer = new StatementAnalyzer(
            analysis,
            metadata,
            sqlParser,
            new AllowAllAccessControl(),
            session,
            experimentalSyntaxEnabled,
            queryExplainer);

    RelationType descriptor = analyzer.process(table, context);
    node.getWhere().ifPresent(where -> analyzer.analyzeWhere(node, descriptor, context, where));

    accessControl.checkCanDeleteFromTable(session.getRequiredTransactionId(), session.getIdentity(), tableName);

    return new RelationType(Field.newUnqualified("rows", BIGINT));
}

@Override
protected Void visitDelete(Delete node, Integer context)
{
    builder.append("DELETE FROM ")
            .append(node.getTable().getName());

    if (node.getWhere().isPresent()) {
        builder.append(" WHERE ")
                .append(formatExpression(node.getWhere().get()));
    }

    return null;
}

@Override
public Node visitDelete(SqlBaseParser.DeleteContext context)
{
    return new Delete(
            getLocation(context),
            new Table(getLocation(context), getQualifiedName(context.qualifiedName())),
            visitIfPresent(context.booleanExpression(), Expression.class));
}

@Test
public void testDelete()
{
    assertStatement("DELETE FROM t", new Delete(table(QualifiedName.of("t")), Optional.empty()));

    assertStatement("DELETE FROM t WHERE a = b", new Delete(table(QualifiedName.of("t")), Optional.of(
            new ComparisonExpression(ComparisonExpression.Type.EQUAL,
                    new QualifiedNameReference(QualifiedName.of("a")),
                    new QualifiedNameReference(QualifiedName.of("b"))))));
}

@Override
protected Void visitDelete(Delete node, Integer context)
{
    builder.append("DELETE FROM ")
            .append(node.getTable().getName());

    if (node.getWhere().isPresent()) {
        builder.append(" WHERE ")
                .append(formatExpression(node.getWhere().get()));
    }

    return null;
}

public void setDelete(Delete delete)
{
    this.delete = Optional.of(delete);
}

public Optional<Delete> getDelete()
{
    return delete;
}

/**
 * Deletes documents from elasticsearch using the predicate provided in the query. This request is 
 * executed in atleast two steps:
 * <ol>
 * <li>fetch document _id's that match the query</li>
 * <li>add deletion of each id to a bulk request</li>
 * <li>execute bulk request when it contains fetch.size items (see {@link Utils}) and continue</li>
 * <li>execute bulk when all _id's have been added</li>
 * </ol>
 * @param sql
 * @param delete
 * @param index
 * @return
 * @throws SQLException
 */
public int execute(String sql, Delete delete, String index) throws SQLException {
    return delete(sql, delete, index, Utils.getIntProp(props, Utils.PROP_FETCH_SIZE, 2500));
}