com.jpattern.orm.session.OrmSession Maven / Gradle / Ivy

Go to download
package com.jpattern.orm.session;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import com.jpattern.logger.ILogger;
import com.jpattern.orm.classtool.IOrmClassTool;
import com.jpattern.orm.classtool.IOrmClassToolMap;
import com.jpattern.orm.exception.OrmException;
import com.jpattern.orm.exception.OrmNotUniqueResultException;
import com.jpattern.orm.exception.OrmOptimisticLockException;
import com.jpattern.orm.generator.ResultSetMethodHelper;
import com.jpattern.orm.generator.wrapper.WrapperTypeArray;
import com.jpattern.orm.logger.OrmLogger;
import com.jpattern.orm.query.DeleteQuery;
import com.jpattern.orm.query.CustomFindQuery;
import com.jpattern.orm.query.FindQuery;
import com.jpattern.orm.query.SqlExecutor;
import com.jpattern.orm.query.UpdateQuery;
import com.jpattern.orm.query.OrmClassToolMapNameSolver;
import com.jpattern.orm.query.OrmCustomFindQuery;
import com.jpattern.orm.query.OrmDeleteQuery;
import com.jpattern.orm.query.OrmFindQuery;
import com.jpattern.orm.query.OrmUpdateQuery;
import com.jpattern.orm.query.PlainSqlExecutor;
import com.jpattern.orm.script.IScriptExecutor;
import com.jpattern.orm.script.ScriptExecutor;
import com.jpattern.orm.transaction.ITransaction;
import com.jpattern.orm.transaction.ITransactionDefinition;
import com.jpattern.orm.transaction.TransactionDefinition;

/**
 * 
 * @author Francesco Cina
 *
 * 27/giu/2011
 */
public class OrmSession implements SessionSqlPerformer {

	private final ILogger logger = OrmLogger.getOrmLogger(this.getClass());
	private final IOrmClassToolMap ormClassToolMap;
	private final SessionStrategy sessionStrategy;
	private final ResultSetMethodHelper rsMethodHelper;
	private final WrapperTypeArray wrapperTypeArray;

	public OrmSession(IOrmClassToolMap ormClassToolMap, SessionStrategy sessionStrategy, ResultSetMethodHelper rsMethodHelper) {
		this.ormClassToolMap = ormClassToolMap;
		this.sessionStrategy = sessionStrategy;
		this.rsMethodHelper = rsMethodHelper;
		wrapperTypeArray = new WrapperTypeArray(rsMethodHelper);
	}

	@Override
	public final ITransaction transaction() throws OrmException {
		return this.transaction(new TransactionDefinition());
	}

	@Override
	public final  FindQuery findQuery(Class clazz) throws OrmException {
		final OrmFindQuery query = new OrmFindQuery(ormClassToolMap , this, clazz, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.register(clazz);
		query.setNameSolver(nameSolver);
		return query;
	}

	@Override
	public final  FindQuery findQuery(Class clazz, String alias) throws OrmException {
		final OrmFindQuery query = new OrmFindQuery(ormClassToolMap , this, clazz, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.register(clazz, alias);
		query.setNameSolver(nameSolver);
		return query;
	}

	@Override
	public final CustomFindQuery findQuery(String selectClause, Class clazz, String alias ) throws OrmException {
		final OrmCustomFindQuery query = new OrmCustomFindQuery(selectClause, ormClassToolMap , this, clazz, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.register(clazz, alias);
		query.setNameSolver(nameSolver);
		return query;
	}

	public final IOrmClassToolMap getOrmClassToolMap() {
		return ormClassToolMap;
	}

	@Override
	public final  T find(Class clazz, Object value) throws OrmException {
		return this.find(clazz, new Object[]{value});
	}

	@Override
	public final  T find(Class clazz, Object[] values) throws OrmException {
		final IOrmClassTool ormClassTool = getOrmClassToolMap().getOrmClassTool(clazz);
		final ResultSetReader resultSetReader = new ResultSetReader() {

			@Override
			public T read(ResultSet resultSet) throws SQLException {
				if ( resultSet.next() ) {
					return ormClassTool.getOrmPersistor().mapRow("", resultSet, 0) ;
				}
				return null;
			}
		};
		final SqlPerformer sqlExec = sqlPerformer();
		sqlExec.setMaxRows(1);
		return sqlExec.query(ormClassTool.getOrmCRUDQuery().getLoadQuery(), resultSetReader, wrapperTypeArray.unWrap(values));
	}

	@Override
	public final  T findUnique(Class clazz, Object value) throws OrmException, OrmNotUniqueResultException {
		final T result = this.find(clazz, value);
		if (result==null) {
			throw new OrmNotUniqueResultException("The query execution returned a number of objects different than 1");
		}
		return result;
	}

	@Override
	public final  T findUnique(Class clazz, Object[] values) throws OrmException, OrmNotUniqueResultException {
		final T result = this.find(clazz, values);
		if (result==null) {
			throw new OrmNotUniqueResultException("The query execution returned a number of objects different than 1");
		}
		return result;
	}

	@Override
	public final  int save(final T object) throws OrmException {
		int result = 0;
		@SuppressWarnings("unchecked")
		final IOrmClassTool ormClassTool = (IOrmClassTool) getOrmClassToolMap().getOrmClassTool(object.getClass());
		final SqlPerformer sqlExec = sqlPerformer();
		//		final String sql = ormClassTool.getOrmCRUDQuery().getSaveQuery();

		//CHECK IF OBJECT HAS A 'VERSION' FIELD
		if (ormClassTool.getClassMapper().getTableMap().isVersionable()) {
			ormClassTool.getOrmPersistor().increaseVersion(object, true);
		}


		if (!ormClassTool.getOrmPersistor().useKeyGenerators(object)) {
			logger.debug("Saving object without using generators");
			final Object[] args = ormClassTool.getOrmPersistor().allValues(object);
			final String sql = ormClassTool.getOrmCRUDQuery().getSaveQueryWithoutGenerators();
			result = sqlExec.update(sql, args);
		} else {
			logger.debug("Saving object using generators");
			final Object[] args = ormClassTool.getOrmPersistor().allNotGeneratedValues(object);
			final String sql = ormClassTool.getOrmCRUDQuery().getSaveQuery();
			final GeneratedKeyReader generatedKeyExtractor = new GeneratedKeyReader() {

				@Override
				public void read(ResultSet generatedKeyResultSet) throws SQLException {
					if (generatedKeyResultSet.next()) {
						ormClassTool.getOrmPersistor().updateGeneratedValues(generatedKeyResultSet, object);
					}
				}

				@Override
				public String[] generatedColumnNames() {
					return ormClassTool.getClassMapper().getAllGeneratedColumnDBNames();
				}
			};
			result = sqlExec.update(sql, generatedKeyExtractor, args);
		}
		return result;
	}

	@Override
	public final  int save(final List objects) throws OrmException {
		int result = 0;
		for (final T object : objects) {
			result+=this.save(object);
		}
		return result;
	}

	@Override
	public final  int update(T object) throws OrmException {
		@SuppressWarnings("unchecked")
		final
		IOrmClassTool ormClassTool = (IOrmClassTool) getOrmClassToolMap().getOrmClassTool(object.getClass());
		final SqlPerformer sqlExec = sqlPerformer();

		//CHECK IF OBJECT HAS A 'VERSION' FIELD
		if (ormClassTool.getClassMapper().getTableMap().isVersionable()) {
			final int rightVersion = sqlExec.queryForInt(ormClassTool.getOrmCRUDQuery().getBeanVersionQuery(), ormClassTool.getOrmPersistor().primaryKeyAndVersionValues(object));
			if ( rightVersion==0 ) {
				throw new OrmOptimisticLockException("The bean of class [" + object.getClass() + "] cannot be updated. Version in the DB is not the expected one.");
			}
			ormClassTool.getOrmPersistor().increaseVersion(object, false);
		}

		//UPDATE OBJECT
		final Object[] pkArgs = ormClassTool.getOrmPersistor().primaryKeyValues(object);
		final Object[] npkArgs = ormClassTool.getOrmPersistor().notPrimaryKeyValues(object);
		final Object[] args = new Object[ npkArgs.length + pkArgs.length ];
		int i=0;
		for (final Object value : npkArgs) {
			args[i++] = value;
		}
		for (final Object value : pkArgs) {
			args[i++] = value;
		}
		return sqlExec.update(ormClassTool.getOrmCRUDQuery().getUpdateQuery(), args);
	}


	@Override
	public final  int update(final List objects) throws OrmException {
		int result = 0;
		for (final T object : objects) {
			result += this.update(object);
		}
		return result;
	}

	@Override
	public final UpdateQuery updateQuery(Class clazz) throws OrmException {
		final OrmUpdateQuery update = new OrmUpdateQuery(clazz, ormClassToolMap, this, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.alwaysResolveWithoutAlias(true);
		nameSolver.register(clazz);
		update.setNameSolver(nameSolver);
		return update;
	}

	@Override
	public final UpdateQuery updateQuery(Class clazz, String alias) throws OrmException {
		final OrmUpdateQuery update = new OrmUpdateQuery(clazz, ormClassToolMap, this, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.alwaysResolveWithoutAlias(true);
		nameSolver.register(clazz, alias);
		update.setNameSolver(nameSolver);
		return update;
	}

	@Override
	public final  int delete(T object) throws OrmException {
		@SuppressWarnings("unchecked")
		final
		IOrmClassTool ormClassTool = (IOrmClassTool) getOrmClassToolMap().getOrmClassTool(object.getClass());
		final SqlPerformer sqlExec = sqlPerformer();
		return sqlExec.update(ormClassTool.getOrmCRUDQuery().getDeleteQuery(), ormClassTool.getOrmPersistor().primaryKeyValues(object));
	}

	@Override
	public final  int delete(final List objects) throws OrmException {
		int result = 0;
		for (final T object : objects) {
			result += this.delete(object);
		}
		return result;
	}

	@Override
	public final DeleteQuery deleteQuery(Class clazz) throws OrmException {
		final OrmDeleteQuery delete = new OrmDeleteQuery(clazz, ormClassToolMap, this, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.register(clazz);
		nameSolver.alwaysResolveWithoutAlias(true);
		delete.setNameSolver(nameSolver);
		return delete;
	}

	@Override
	public final DeleteQuery deleteQuery(Class clazz, String alias) throws OrmException {
		final OrmDeleteQuery delete = new OrmDeleteQuery(clazz, ormClassToolMap, this, rsMethodHelper);
		final OrmClassToolMapNameSolver nameSolver = new OrmClassToolMapNameSolver(ormClassToolMap);
		nameSolver.register(clazz, alias);
		nameSolver.alwaysResolveWithoutAlias(true);
		delete.setNameSolver(nameSolver);
		return delete;
	}

	@Override
	public final IScriptExecutor scriptExecutor() throws OrmException {
		return new ScriptExecutor(this);
	}

	@Override
	public final SqlExecutor sqlExecutor() {
		return new PlainSqlExecutor(this);
	}

	@Override
	public ITransaction transaction(
			ITransactionDefinition transactionDefinition) throws OrmException {
		return sessionStrategy.getTransaction(transactionDefinition);
	}

	@Override
	public SqlPerformer sqlPerformer() throws OrmException {
		return new PlainSqlPerformer(sessionStrategy.sqlPerformerStrategy());
	}

	@Override
	public  int saveOrUpdate(T object) throws OrmException {
		@SuppressWarnings("unchecked")
		final IOrmClassTool ormClassTool = (IOrmClassTool) getOrmClassToolMap().getOrmClassTool(object.getClass());

		if (ormClassTool.getOrmPersistor().hasConditionalGenerator()) {
			if(ormClassTool.getOrmPersistor().useKeyGenerators(object)) {
				return save(object);
			} else {
				return update(object);
			}
		} else {
			int result = update(object);
			if (result < 1) {
				result = save(object);
			}
			return result;
		}
	}

	@Override
	public  int saveOrUpdate(List objects) throws OrmException {
		int result = 0;
		for (final T object : objects) {
			result += this.saveOrUpdate(object);
		}
		return result;
	}

}