/*
* HA-JDBC: High-Availability JDBC
* Copyright (C) 2012 Paul Ferraro
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package net.sf.hajdbc.sql;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import net.sf.hajdbc.Database;
import net.sf.hajdbc.invocation.InvocationStrategies;
import net.sf.hajdbc.invocation.InvocationStrategy;
import net.sf.hajdbc.invocation.Invoker;
import net.sf.hajdbc.invocation.LockingInvocationStrategy;
import net.sf.hajdbc.util.reflect.Methods;
/**
* @author Paul Ferraro
* @param <D>
* @param <S>
*/
public abstract class AbstractPreparedStatementInvocationHandler<Z, D extends Database<Z>, S extends PreparedStatement, F extends AbstractPreparedStatementProxyFactory<Z, D, S>> extends AbstractStatementInvocationHandler<Z, D, S, F>
{
private static final Set<Method> databaseReadMethodSet = Methods.findMethods(PreparedStatement.class, "getMetaData", "getParameterMetaData");
private static final Method executeMethod = Methods.getMethod(PreparedStatement.class, "execute");
private static final Method executeUpdateMethod = Methods.getMethod(PreparedStatement.class, "executeUpdate");
private static final Method executeQueryMethod = Methods.getMethod(PreparedStatement.class, "executeQuery");
private static final Method clearParametersMethod = Methods.getMethod(PreparedStatement.class, "clearParameters");
private static final Method addBatchMethod = Methods.getMethod(PreparedStatement.class, "addBatch");
private final Set<Method> setMethods;
public AbstractPreparedStatementInvocationHandler(Class<S> statementClass, F proxyFactory, Set<Method> setMethods)
{
super(statementClass, proxyFactory);
this.setMethods = setMethods;
}
@Override
protected ProxyFactoryFactory<Z, D, S, SQLException, ?, ? extends Exception> getProxyFactoryFactory(S object, Method method, Object... parameters) throws SQLException
{
if (method.equals(executeQueryMethod))
{
return new ResultSetProxyFactoryFactory<Z, D, S>(this.getProxyFactory().getTransactionContext(), this.getProxyFactory().getInputSinkRegistry());
}
return super.getProxyFactoryFactory(object, method, parameters);
}
/**
* @see net.sf.hajdbc.sql.AbstractStatementInvocationHandler#getInvocationStrategy(java.sql.Statement, java.lang.reflect.Method, java.lang.Object[])
*/
@Override
protected InvocationStrategy getInvocationStrategy(S statement, Method method, Object... parameters) throws SQLException
{
if (databaseReadMethodSet.contains(method))
{
return InvocationStrategies.INVOKE_ON_NEXT;
}
if (this.setMethods.contains(method) || method.equals(clearParametersMethod) || method.equals(addBatchMethod))
{
return InvocationStrategies.INVOKE_ON_EXISTING;
}
if (method.equals(executeMethod) || method.equals(executeUpdateMethod))
{
return this.getProxyFactory().getTransactionContext().start(new LockingInvocationStrategy(InvocationStrategies.TRANSACTION_INVOKE_ON_ALL, this.getProxyFactory().getLocks()), this.getProxyFactory().getParentProxy());
}
if (method.equals(executeQueryMethod))
{
List<Lock> locks = this.getProxyFactory().getLocks();
int concurrency = statement.getResultSetConcurrency();
boolean selectForUpdate = this.getProxyFactory().isSelectForUpdate();
if (locks.isEmpty() && (concurrency == ResultSet.CONCUR_READ_ONLY) && !selectForUpdate)
{
boolean repeatableReadSelect = (statement.getConnection().getTransactionIsolation() >= Connection.TRANSACTION_REPEATABLE_READ);
return repeatableReadSelect ? InvocationStrategies.INVOKE_ON_PRIMARY : InvocationStrategies.INVOKE_ON_NEXT;
}
InvocationStrategy strategy = InvocationStrategies.TRANSACTION_INVOKE_ON_ALL;
if (!locks.isEmpty())
{
strategy = new LockingInvocationStrategy(strategy, locks);
}
return selectForUpdate ? this.getProxyFactory().getTransactionContext().start(strategy, this.getProxyFactory().getParentProxy()) : strategy;
}
return super.getInvocationStrategy(statement, method, parameters);
}
@Override
protected <R> Invoker<Z, D, S, R, SQLException> getInvoker(S statement, final Method method, final Object... parameters) throws SQLException
{
if (this.isSetParameterMethod(method) && (parameters.length > 1))
{
return this.getInvoker(method.getParameterTypes()[1], 1, statement, method, parameters);
}
return super.getInvoker(statement, method, parameters);
}
@Override
protected boolean isBatchMethod(Method method)
{
return method.equals(addBatchMethod) || method.equals(clearParametersMethod) || this.isSetParameterMethod(method) || super.isBatchMethod(method);
}
private boolean isSetParameterMethod(Method method)
{
Class<?>[] types = method.getParameterTypes();
return this.setMethods.contains(method) && (types.length > 0) && this.isIndexType(types[0]);
}
protected boolean isIndexType(Class<?> type)
{
return type.equals(Integer.TYPE);
}
}