Subversion Repositories general

package ak.hostadmiral.util;

import java.util.Iterator;
import java.util.Collection;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;
import net.sf.hibernate.type.Type;

public class HibernateUtil
{
        public static final int DATABASE_VERSION = 1;

        private static       Configuration  configuration;
        private static       SessionFactory sessionFactory;
        private static final ThreadLocal    hibernateBean = new ThreadLocal();
    private static       boolean        validated     = false;

    private static void validate()
                throws HibernateException, ModelException
    {
        synchronized(HibernateUtil.class) {
                if(validated) return;

                        Collection versions = currentSession().find("from DatabaseVersion");

            if(versions == null || versions.size() == 0)
                throw new ModelException("Database structure version not found");

            if(versions.size() > 1)
                throw new ModelException("Too much entries in database structure version table");

            int version = ((DatabaseVersion)versions.iterator().next()).getVersion();
            if(version != DATABASE_VERSION)
                throw new ModelException("Expected database structure version "
                        + DATABASE_VERSION + ", found " + version);

                validated = true;
        }
    }

        public static Configuration getConfiguration()
                throws HibernateException
        {
                if(configuration == null)
                        configuration = new Configuration();

                return configuration;
        }

        public static SessionFactory getSessionFactory()
                throws HibernateException
        {
                if(sessionFactory == null)
                        sessionFactory = getConfiguration().configure().buildSessionFactory();

                return sessionFactory;
        }

        private static HibernateBean currentBean()
                throws HibernateException
        {
                HibernateBean hb = (HibernateBean)hibernateBean.get();

                if(hb == null) {
                        hb = new HibernateBean();
                        hb.session = getSessionFactory().openSession();
                        hibernateBean.set(hb);
                }
                return hb;
        }

        public static Session currentSession()
                throws HibernateException
        {
                return currentBean().session;
        }

        public static void closeSession()
                throws HibernateException, ModelException
        {
                HibernateBean hb = (HibernateBean)hibernateBean.get();

                if(hb == null)
                        throw new ModelException("No session found for this thread");

                hibernateBean.set(null);
                hb.session.close();
        }

        public static void beginTransaction()
                throws HibernateException, ModelException
        {
                HibernateBean hb = (HibernateBean)hibernateBean.get();

                if(hb != null && hb.transaction != null)
                        throw new ModelException("Transaction is already open");

                currentBean().transaction = currentSession().beginTransaction();

                // validate database structure version
        if(!validated) // just try to speed up by avoiding synchronization
                        validate();
        }

        public static boolean isTransactionOpen()
                throws HibernateException, ModelException
        {
                HibernateBean hb = (HibernateBean)hibernateBean.get();

                return (hb != null) && (hb.transaction != null);
        }

        public static void commitTransaction()
                throws HibernateException, ModelException
        {
                HibernateBean hb = (HibernateBean)hibernateBean.get();

                if(hb == null || hb.transaction == null)
                        throw new ModelException("No open transaction");

                hb.transaction.commit();
                hb.transaction = null;
        }

        public static void rollbackTransaction()
                throws HibernateException, ModelException
        {
                HibernateBean hb = (HibernateBean)hibernateBean.get();

                if(hb == null || hb.transaction == null)
                        throw new ModelException("No open transaction");

                hb.transaction.rollback();
                hb.transaction = null;
        }

    public static List sqlQuery(String query, Object[] values)
                throws ModelException
    {
        Connection        con;
        PreparedStatement stmt;

        try {
                con = currentSession().connection();
        }
        catch(HibernateException ex) {
                        throw new ModelException(ex);
        }

        try {
                stmt = con.prepareStatement(query);
        }
        catch(SQLException ex) {
                        throw new ModelException(ex);
        }

                try {
                        if(values != null) {
                                for(int i = 0; i < values.length; i++)
                                        stmt.setObject(i+1, values[i]);
                        }

                        List res = new ArrayList();
                        ResultSet rs = stmt.executeQuery();
                        while(rs.next()) {
                                res.add(rs.getObject(1));
                        }
                        return res;
                }
                catch(SQLException ex)
                {
                        throw new ModelException(ex);
                }
                finally {
                try {
                                stmt.close();
                        }
                        catch(SQLException ex) {
                                ex.printStackTrace();
                        }
                }
    }

    public static List pageableList(int pageSize, int pageNumber,
                        String query, Class classToLoad, String[] returnAliases, Class[] returnClasses,
                        Object[] values, Type[] types)
                throws ModelException
    {
                try {
                        Query hq = currentSession().createSQLQuery(
                                query, returnAliases, returnClasses);

                        if(values != null && types != null) {
                                for(int i  = 0; i < values.length; i++)
                                        hq.setParameter(i, values[i], types[i]);
                        }

                        if(pageSize > 0) {
                                hq.setFirstResult(pageSize * pageNumber);
                                hq.setMaxResults(pageSize);
                        }

                        return selectClassColumn(classToLoad, hq.list());
                        // FIXME: really no other way in Hibernate?
                }
                catch(HibernateException ex)
                {
                        throw new ModelException(ex);
                }
    }

        protected static List selectClassColumn(Class classToLoad, List list)
                throws ModelException
        {
                List res = new ArrayList();

                if(list == null || list.size() == 0) return res;

                Object o = list.get(0);
                if(o == null)
                        throw new ModelException(
                                "First element in the list is null, cannot determine it type");

                if(!(o instanceof Object[])) {
                        if(classToLoad.isInstance(o))
                                return list;
                        else
                                throw new ModelException("First element in the list is instance of "
                                        + o.getClass().getName() + ", which is not java.lang.Object[] or "
                                        + classToLoad.getName());
                }

        Object[] oa = (Object[])o;
        int      pos = -1;

        for(int i = 0; i < oa.length; i++) {
                if(classToLoad.isInstance(oa[i])) {
                        if(pos < 0)
                                pos = i;
                        else
                                        throw new ModelException("First row of the list has several elements of type "
                                                + classToLoad.getName());
                }
        }
        if(pos < 0) {
                        throw new ModelException("First row of the list has no elements of type "
                                + classToLoad.getName());
        }

        for(Iterator i = list.iterator(); i.hasNext(); ) {
                Object[] e = (Object[])i.next();
                res.add(e[pos]);
        }

                return res;
        }

        public static String formOrderClause(Integer[] sortingKeys, Map fieldMap)
                throws ModelException
        {
                if(sortingKeys == null || sortingKeys.length == 0) return "";

                StringBuffer buf = new StringBuffer(" order by ");

                for(int i = 0; i < sortingKeys.length; i++) {
                        if(i > 0) buf.append(",");

                        String field = (String)fieldMap.get(sortingKeys[i]);
                        if(field == null)
                                throw new ModelException(
                                        "Field for sorting key " + sortingKeys[i] + " not found");

                        buf.append(field);
                }

                return buf.toString();
        }

        static class HibernateBean
        {
                public Session     session;
                public Transaction transaction;
        }
}