Here is a proposal for an enhanced EnumUserType that allow you to
specify if the Name or the Ordinal of an Enum constant should end up in
the database column:

public class EnumUserType implements EnhancedUserType, ParameterizedType {

    private Class<Enum> enumClass;
    private boolean useName;
    private final int ORDINAL_FOR_NULL = -1;

    public void setParameterValues(Properties parameters) {
        String enumClassName =
parameters.getProperty("enumClassName").trim();
        try {
            enumClass = (Class<Enum>) Class.forName(enumClassName);
        } catch (ClassNotFoundException cnfe) {
            throw new HibernateException("Enum class not found", cnfe);
        }
        String columnType = parameters.getProperty("columnType").trim();
        useName = !columnType.equalsIgnoreCase("INTEGER");
    }

    public Object assemble(Serializable cached, Object owner) throws
HibernateException {
        return cached;
    }

    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    public Serializable disassemble(Object value) throws
HibernateException {
        return (Enum) value;
    }

    public boolean equals(Object x, Object y) throws HibernateException {
        return x == y;
    }

    public int hashCode(Object x) throws HibernateException {
        return x.hashCode();
    }

    public boolean isMutable() {
        return false;
    }

    public Object replace(Object original, Object target, Object owner)
            throws HibernateException {
        return original;
    }

    public Class returnedClass() {
        return enumClass;
    }

    public int[] sqlTypes() {
        return new int[]{useName ? Types.VARCHAR : Types.INTEGER};
    }

    public Object nullSafeGet(ResultSet resultSet, String[] names,
Object owner)
            throws HibernateException, SQLException {
        if (useName) {
            String name = resultSet.getString(names[0]);
            return resultSet.wasNull() ? null : Enum.valueOf(enumClass,
name);
        } else {
            int ordinal = resultSet.getInt(names[0]);
            if (resultSet.wasNull() || (ordinal == ORDINAL_FOR_NULL)) {
                return null;
            } else {
                return enumClass.getEnumConstants()[ordinal];
            }
        }
    }

    public void nullSafeSet(PreparedStatement st, Object value, int index)
            throws HibernateException, SQLException {
        if (useName) {
            if (value == null) {
                st.setNull(index, Types.VARCHAR);
            } else {
                st.setString(index, ((Enum) value).name());
            }
        } else {
            if (value == null) {
                st.setInt(index, ORDINAL_FOR_NULL);
            } else {
                st.setInt(index, ((Enum) value).ordinal());
            }
        }
    }

    public Object fromXMLString(String xmlValue) {
        if (useName) {
            return Enum.valueOf(enumClass, xmlValue);
        } else {
            int ordinal = Integer.parseInt(xmlValue);
            return enumClass.getEnumConstants()[ordinal];
        }
    }

    public String objectToSQLString(Object value) {
        if (useName) {
            return '\'' + ((Enum) value).name() + '\'';
        } else {
            return String.valueOf(((Enum) value).ordinal());
        }
    }

    public String toXMLString(Object value) {
        if (useName) {
            return ((Enum) value).name();
        } else {
            return String.valueOf(((Enum) value).ordinal());
        }
    }
}