http://news.ycombinator.com/item?id=2970637

UPDATE: I also found this helpful site: gitref.org

During a system’s life cycle requirements change and components are refactored. This includes databases as well and particularly as data grows. Decisions and assumptions are made at the beginning of a system’s life cycle that may or may not hold up over years of operation and it’s good practice to continually analyze how well the initial design is working.

When doing analysis in support of refactoring database schemas in MySQL, I’ve found this little bit of SQL to be invaluable.

Code:

SELECT * FROM TABLE PROCEDURE analyse();

(I suggest giving it a try on a small table with few rows.)

PROCEDURE ANALYSE interrogates the values in a table, shows the smallest and largest values and suggests a type for each column. While the results frequently indicate that an ENUM type is the most appropriate you can add arguments to the ANALYSE procedure to get more rational suggestions. However, even with no arguments the results can be useful.

For example, you might see that the max value of a column actually is smaller than the type that it’s using. I’ve frequently seen INT(11) columns that would work fine as a MEDIUMINT or even TINYINT. Or your might find that an ENUM type is better since the distribution of values is small in a VARCHAR column. (The benefit of an ENUM is that the data is stored as an integer rather than the string value so its’ footprint on the disk can be significantly smaller).

Anyway, while it’s not a panacea, PROCECURE ANALYSE() is another helpful tool.

public class GenericDAOHibernate<T, PK extends Serializable> implements GenericDAO<T, PK> {

	/** log4j Logger for class GenericDAOHibernate */
	private static Logger logger = Logger.getLogger(GenericDAOHibernate.class.getName());

    private Class<T> persistentClass;

    private HibernateTemplate hibernateTemplate;

    @Autowired(required=true)
    private SessionFactory sessionFactory;

// [...]

@Override
public Class<T> getPersistentClass() {
    return persistentClass;
}

@Override
public int countAll() {

    @SuppressWarnings({ "unchecked", "rawtypes" })
    List results = (List) hibernateTemplate.execute(new HibernateCallback() {
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            return session.createCriteria(getPersistentClass())
                .setProjection(Projections.rowCount())
                .list();
            }
        });

        // Here I use the Spring DataAccessUtils class to interpret the result set
        int result = DataAccessUtils.intResult(results)

        logger.debug("count retrieved: " + result;

        return result;
}

I also added another convenience method that uses the Example Criteria API so we can generate a count with a pre-configured Entity:

@Override
public int countByExample(final T exampleInstance)

    @SuppressWarnings({ "unchecked", "rawtypes" })
    List results = (List) hibernateTemplate.execute(new HibernateCallback() {
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            return session.createCriteria(getPersistentClass())
                .add(Example.create(exampleInstance))
                .setProjection(Projections.rowCount())
                .list();
            }
        });

        // Here I use the Spring DataAccessUtils class to interpret the result set
        int result = DataAccessUtils.intResult(results)

        logger.debug("count retrieved: " + result;

        return result;

I plan to package up some of the Generics code at some point and will post a link to download it or to a public source code repository.