package org.skife.jdbi.v2;
import org.skife.jdbi.v2.exceptions.UnableToCreateStatementException;
import org.skife.jdbi.v2.exceptions.UnableToExecuteStatementException;
import org.skife.jdbi.v2.tweak.ResultColumnMapper;
import org.skife.jdbi.v2.tweak.ResultSetMapper;
import org.skife.jdbi.v2.tweak.RewrittenStatement;
import org.skife.jdbi.v2.tweak.SQLLog;
import org.skife.jdbi.v2.tweak.StatementBuilder;
import org.skife.jdbi.v2.tweak.StatementCustomizer;
import org.skife.jdbi.v2.tweak.StatementLocator;
import org.skife.jdbi.v2.tweak.StatementRewriter;
import org.skife.jdbi.v2.util.SingleColumnMapper;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public class PreparedBatch extends SQLStatement<PreparedBatch>
{
private final List<PreparedBatchPart> parts = new ArrayList<PreparedBatchPart>();
private Binding currentBinding;
PreparedBatch(StatementLocator locator,
StatementRewriter rewriter,
Handle handle,
StatementBuilder statementBuilder,
String sql,
ConcreteStatementContext ctx,
SQLLog log,
TimingCollector timingCollector,
Collection<StatementCustomizer> statementCustomizers,
Foreman foreman,
ContainerFactoryRegistry containerFactoryRegistry)
{
super(new Binding(), locator, rewriter, handle, statementBuilder, sql, ctx, log, timingCollector, statementCustomizers, foreman, containerFactoryRegistry);
this.currentBinding = new Binding();
}
@Override
public PreparedBatch define(String key, Object value)
{
getContext().setAttribute(key, value);
return this;
}
@Override
public PreparedBatch define(final Map<String, ? extends Object> values)
{
if (values != null) {
for (Map.Entry<String, ? extends Object> entry: values.entrySet())
{
getContext().setAttribute(entry.getKey(), entry.getValue());
}
}
return this;
}
public int[] execute() {
return (int[]) internalBatchExecute(null, null);
}
@SuppressWarnings("unchecked")
public <GeneratedKeyType> GeneratedKeys<GeneratedKeyType> executeAndGenerateKeys(final ResultSetMapper<GeneratedKeyType> mapper) {
return (GeneratedKeys<GeneratedKeyType>) internalBatchExecute(new QueryResultMunger<GeneratedKeys<GeneratedKeyType>>() {
public GeneratedKeys<GeneratedKeyType> munge(Statement results) throws SQLException {
return new GeneratedKeys<GeneratedKeyType>(mapper,
PreparedBatch.this,
results,
getContext(),
getContainerMapperRegistry());
}
}, null);
}
@SuppressWarnings("unchecked")
public <GeneratedKeyType> GeneratedKeys<GeneratedKeyType> executeAndGenerateKeys(final ResultSetMapper<GeneratedKeyType> mapper,
String... columnNames) {
return (GeneratedKeys<GeneratedKeyType>) internalBatchExecute(new QueryResultMunger<GeneratedKeys<GeneratedKeyType>>() {
public GeneratedKeys<GeneratedKeyType> munge(Statement results) throws SQLException {
return new GeneratedKeys<GeneratedKeyType>(mapper,
PreparedBatch.this,
results,
getContext(),
getContainerMapperRegistry());
}
}, columnNames);
}
@SuppressWarnings("unchecked")
public <GeneratedKeyType> GeneratedKeys<GeneratedKeyType> executeAndGenerateKeys(final ResultColumnMapper<GeneratedKeyType> mapper) {
return executeAndGenerateKeys(new SingleColumnMapper<GeneratedKeyType>(mapper));
}
public <GeneratedKeyType> GeneratedKeys<GeneratedKeyType> executeAndGenerateKeys(ResultColumnMapper<GeneratedKeyType> mapper,
String... columnNames) {
return executeAndGenerateKeys(new SingleColumnMapper<GeneratedKeyType>(mapper), columnNames);
}
private <Result> Object internalBatchExecute(QueryResultMunger<Result> munger, String[] columnNames) {
boolean generateKeys = munger != null;
if (parts.size() == 0) {
if (generateKeys) {
throw new IllegalArgumentException("Unable generate keys for a not prepared batch");
}
return new int[]{};
}
PreparedBatchPart current = parts.get(0);
final String my_sql ;
try {
my_sql = getStatementLocator().locate(getSql(), getContext());
}
catch (Exception e) {
throw new UnableToCreateStatementException(String.format("Exception while locating statement for [%s]",
getSql()), e, getContext());
}
final RewrittenStatement rewritten = getRewriter().rewrite(my_sql, current.getParams(), getContext());
PreparedStatement stmt = null;
try {
try {
Connection connection = getHandle().getConnection();
if (generateKeys) {
if (columnNames != null) {
stmt = connection.prepareStatement(rewritten.getSql(), columnNames);
} else {
stmt = connection.prepareStatement(rewritten.getSql(), Statement.RETURN_GENERATED_KEYS);
}
} else {
stmt = connection.prepareStatement(rewritten.getSql(), Statement.NO_GENERATED_KEYS);
}
addCleanable(Cleanables.forStatement(stmt));
}
catch (SQLException e) {
throw new UnableToCreateStatementException(e, getContext());
}
try {
for (PreparedBatchPart part : parts) {
rewritten.bind(part.getParams(), stmt);
stmt.addBatch();
}
}
catch (SQLException e) {
throw new UnableToExecuteStatementException("Exception while binding parameters", e, getContext());
}
beforeExecution(stmt);
try {
final long start = System.nanoTime();
final int[] rs = stmt.executeBatch();
final long elapsedTime = System.nanoTime() - start;
getLog().logPreparedBatch(elapsedTime / 1000000L, rewritten.getSql(), parts.size());
getTimingCollector().collect(elapsedTime, getContext());
afterExecution(stmt);
return generateKeys ? munger.munge(stmt) : rs;
}
catch (SQLException e) {
throw new UnableToExecuteStatementException(e, getContext());
}
}
finally {
try {
if (!generateKeys) {
cleanup();
}
}
finally {
this.parts.clear();
}
}
}
public PreparedBatchPart add()
{
PreparedBatchPart part = new PreparedBatchPart(this.currentBinding,
this,
getStatementLocator(),
getRewriter(),
getHandle(),
getStatementBuilder(),
getSql(),
getConcreteContext(),
getLog(),
getTimingCollector(),
getForeman(),
getContainerMapperRegistry());
parts.add(part);
this.currentBinding = new Binding();
return part;
}
public PreparedBatch add(Object... args)
{
PreparedBatchPart part = add();
for (int i = 0; i < args.length; ++i) {
part.bind(i, args[i]);
}
return this;
}
public PreparedBatchPart add(Map<String, ? extends Object> args)
{
PreparedBatchPart part = add();
part.bindFromMap(args);
return part;
}
public int getSize()
{
return parts.size();
}
public int size()
{
return parts.size();
}
@Override
protected Binding getParams()
{
return this.currentBinding;
}
}