All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.mysema.query.sql.dml.SQLDeleteClause Maven / Gradle / Ivy

Go to download

SQL support for Querydsl

There is a newer version: 3.7.4
Show newest version
/*
 * Copyright 2011, Mysema Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.mysema.query.sql.dml;

import javax.annotation.Nonnegative;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import com.mysema.query.*;
import com.mysema.query.QueryFlag.Position;
import com.mysema.query.dml.DeleteClause;
import com.mysema.query.sql.*;
import com.mysema.query.types.Expression;
import com.mysema.query.types.Predicate;
import com.mysema.query.types.ValidatingVisitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * SQLDeleteClause defines a DELETE clause
 *
 * @author tiwe
 *
 */
public class SQLDeleteClause extends AbstractSQLClause implements DeleteClause {

    private static final Logger logger = LoggerFactory.getLogger(SQLDeleteClause.class);

    private static final ValidatingVisitor validatingVisitor = new ValidatingVisitor("Undeclared path '%s'. " +
            "A delete operation can only reference a single table. " +
            "Consider this alternative: DELETE ... WHERE EXISTS (subquery)");

    private final Connection connection;

    private final RelationalPath entity;

    private final List batches = new ArrayList();

    private DefaultQueryMetadata metadata = new DefaultQueryMetadata();

    private transient String queryString;

    private transient List constants;

    public SQLDeleteClause(Connection connection, SQLTemplates templates, RelationalPath entity) {
        this(connection, new Configuration(templates), entity);
    }

    public SQLDeleteClause(Connection connection, Configuration configuration, RelationalPath entity) {
        super(configuration);
        this.connection = connection;
        this.entity = entity;
        metadata.addJoin(JoinType.DEFAULT, entity);
        metadata.setValidatingVisitor(validatingVisitor);
    }

    /**
     * Add the given String literal at the given position as a query flag
     *
     * @param position
     * @param flag
     * @return
     */
    public SQLDeleteClause addFlag(Position position, String flag) {
        metadata.addFlag(new QueryFlag(position, flag));
        return this;
    }

    /**
     * Add the given Expression at the given position as a query flag
     *
     * @param position
     * @param flag
     * @return
     */
    public SQLDeleteClause addFlag(Position position, Expression flag) {
        metadata.addFlag(new QueryFlag(position, flag));
        return this;
    }

    /**
     * Add current state of bindings as a batch item
     *
     * @return
     */
    public SQLDeleteClause addBatch() {
        batches.add(metadata);
        metadata = new DefaultQueryMetadata();
        metadata.addJoin(JoinType.DEFAULT, entity);
        metadata.setValidatingVisitor(validatingVisitor);
        return this;
    }

    private PreparedStatement createStatement() throws SQLException{
        SQLSerializer serializer = createSerializer();
        serializer.serializeDelete(metadata, entity);
        queryString = serializer.toString();
        constants = serializer.getConstants();
        logger.debug(queryString);
        PreparedStatement stmt = connection.prepareStatement(queryString);
        setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams());
        return stmt;
    }

    private Collection createStatements() throws SQLException {
        SQLSerializer serializer = createSerializer();
        serializer.serializeDelete(batches.get(0), entity);
        queryString = serializer.toString();
        constants = serializer.getConstants();
        logger.debug(queryString);

        Map stmts = Maps.newHashMap();

        // add first batch
        PreparedStatement stmt = connection.prepareStatement(queryString);
        setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams());
        stmt.addBatch();
        stmts.put(queryString, stmt);

        // add other batches
        for (int i = 1; i < batches.size(); i++) {
            serializer = createSerializer();
            serializer.serializeDelete(batches.get(i), entity);
            stmt = stmts.get(serializer.toString());
            if (stmt == null) {
                stmt = connection.prepareStatement(serializer.toString());
                stmts.put(serializer.toString(), stmt);
            }
            setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams());
            stmt.addBatch();
        }

        return stmts.values();
    }

    @Override
    public long execute() {
        PreparedStatement stmt = null;
        Collection stmts = null;
        try {
            if (batches.isEmpty()) {
                stmt = createStatement();
                listeners.notifyDelete(entity, metadata);
                return stmt.executeUpdate();
            } else {
                stmts = createStatements();
                listeners.notifyDeletes(entity, batches);
                return executeBatch(stmts);
            }
        } catch (SQLException e) {
            throw configuration.translate(queryString, constants, e);
        } finally {
            if (stmt != null) {
                close(stmt);
            }
            if (stmts != null) {
                close(stmts);
            }
        }
    }

    @Override
    public List getSQL() {
        if (batches.isEmpty()) {
            SQLSerializer serializer = createSerializer();
            serializer.serializeDelete(metadata, entity);
            return ImmutableList.of(createBindings(metadata, serializer));
        } else {
            ImmutableList.Builder builder = ImmutableList.builder();
            for (QueryMetadata metadata : batches) {
                SQLSerializer serializer = createSerializer();
                serializer.serializeDelete(metadata, entity);
                builder.add(createBindings(metadata, serializer));
            }
            return builder.build();
        }
    }

    public SQLDeleteClause where(Predicate p) {
        metadata.addWhere(p);
        return this;
    }

    @Override
    public SQLDeleteClause where(Predicate... o) {
        for (Predicate p : o) {
            metadata.addWhere(p);
        }
        return this;
    }

    public SQLDeleteClause limit(@Nonnegative long limit) {
        metadata.setModifiers(QueryModifiers.limit(limit));
        return this;
    }

    @Override
    public String toString() {
        SQLSerializer serializer = createSerializer();
        serializer.serializeDelete(metadata, entity);
        return serializer.toString();
    }

}
    

    

    
            
    
            







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy