SqlTypeConverter.java

/*
 * codjo.net
 *
 * Common Apache License 2.0
 */
package net.codjo.utils;
import java.math.BigDecimal;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.HashMap;
import java.util.Map;
/**
 * Overview.
 * 
 * <p>
 * Description
 * </p>
 *
 * @author $Author: blazart $
 * @version $Revision: 1.2 $
 *
 */
public class SqlTypeConverter {
    // Constante
    private static final Integer ZERO_INTEGER = new Integer(0);
    private static final BigDecimal ZERO_NUMERIC = new BigDecimal(0);
    private static final Float ZERO_FLOAT = new Float(0);
    private static final Double ZERO_DOUBLE = new Double(0);
    private static final Long ZERO_BIGINT = new Long(0);

//	private final static java.sql.Timestamp ZERO_TIMESTAMP = new java.sql.Timestamp(0);
//	private final static java.sql.Date ZERO_DATE = new java.sql.Date(0);
    private static Map javaToSql = new HashMap();

    static {
        javaToSql.put(char.class, new Integer(Types.CHAR));
        javaToSql.put(String.class, new Integer(Types.VARCHAR));
        javaToSql.put(int.class, new Integer(Types.INTEGER));
        javaToSql.put(long.class, new Integer(Types.BIGINT));
        javaToSql.put(float.class, new Integer(Types.FLOAT));
        javaToSql.put(double.class, new Integer(Types.DOUBLE));
        javaToSql.put(boolean.class, new Integer(Types.BIT));
        javaToSql.put(Timestamp.class, new Integer(Types.TIMESTAMP));
        javaToSql.put(Time.class, new Integer(Types.TIME));
        javaToSql.put(java.sql.Date.class, new Integer(Types.DATE));
        javaToSql.put(java.util.Date.class, new Integer(Types.DATE));
        javaToSql.put(BigDecimal.class, new Integer(Types.NUMERIC));
    }

    /**
     * Indique si le type sql correspond a un scalaire.
     *
     * @param sqlType devine !
     *
     * @return idem !
     */
    public static boolean isScalar(Integer sqlType) {
        switch (sqlType.intValue()) {
            case Types.SMALLINT:
            case Types.INTEGER:
            case Types.FLOAT:
            case Types.DOUBLE:
            case Types.BIT:
            case Types.BIGINT:
                return true;
            default:
                return false;
        }
    }


    /**
     * Indique si le type sql correspond a un reel.
     *
     * @param sqlType devine !
     *
     * @return idem !
     */
    public static boolean isDouble(Integer sqlType) {
        switch (sqlType.intValue()) {
            case Types.FLOAT:
            case Types.DOUBLE:
                return true;
            default:
                return false;
        }
    }


    /**
     * Indique si le type sql correspond a une date.
     *
     * @param sqlType devine !
     *
     * @return idem !
     */
    public static boolean isDate(Integer sqlType) {
        switch (sqlType.intValue()) {
            case Types.DATE:
            case Types.TIMESTAMP:
                return true;
            default:
                return false;
        }
    }


    /**
     * Indique si le type sql correspond a un entier.
     *
     * @param sqlType devine !
     *
     * @return idem !
     */
    public static boolean isInteger(Integer sqlType) {
        switch (sqlType.intValue()) {
            case Types.SMALLINT:
            case Types.INTEGER:
                return true;
            default:
                return false;
        }
    }


    /**
     * Indique si le type sql correspond a une String.
     *
     * @param sqlType devine !
     *
     * @return idem !
     */
    public static boolean isString(Integer sqlType) {
        switch (sqlType.intValue()) {
            case Types.CHAR:
            case Types.VARCHAR:
            case Types.LONGVARCHAR:
                return true;
            default:
                return false;
        }
    }


    /**
     * Retourne la valeur par defaut attache a un type SQL.
     *
     * @param sqlType
     *
     * @return La valeur zero / ou null
     *
     * @throws IllegalArgumentException TODO
     */
    public static Object getDefaultSqlValue(int sqlType) {
        switch (sqlType) {
            case Types.CHAR:
            case Types.VARCHAR:
            case Types.LONGVARCHAR:
                return "";
            case Types.SMALLINT:
            case Types.INTEGER:
                return ZERO_INTEGER;
            case Types.FLOAT:
                return ZERO_FLOAT;
            case Types.DOUBLE:
                return ZERO_DOUBLE;
            case Types.NUMERIC:
                return ZERO_NUMERIC;
            case Types.BIGINT:
                return ZERO_BIGINT;
            case Types.TIMESTAMP:
//                return ZERO_TIMESTAMP;
            case Types.DATE:
                return null;

//				return ZERO_DATE;
            case Types.BIT:
                return Boolean.FALSE;
            default:
                throw new IllegalArgumentException("Type SQL" + " est non supporte : "
                    + sqlType);
        }
    }


    /**
     * Indique si le type SQL est de format numerique.
     *
     * @param sqlType type sql.
     *
     * @return <code>true</code> si oui.
     */
    public static boolean isNumeric(int sqlType) {
        if (sqlType == Types.INTEGER
                || sqlType == Types.NUMERIC
                || sqlType == Types.FLOAT
                || sqlType == Types.DOUBLE
                || sqlType == Types.DECIMAL
                || sqlType == Types.SMALLINT
                || sqlType == Types.BIGINT) {
            return true;
        }
        else {
            return false;
        }
    }


    /**
     * DOCUMENT ME!
     *
     * @param cl Description of Parameter
     *
     * @return Description of the Returned Value
     *
     * @throws IllegalArgumentException TODO
     */
    public static Integer toSqlType(Class cl) {
        Integer sqlType = (Integer)javaToSql.get(cl);
        if (sqlType == null) {
            throw new IllegalArgumentException("Type JAVA " + " non supporte : " + cl);
        }
        return sqlType;
    }


    /**
     * Retourne le type Java associe a un type SQL.
     *
     * @param sqlType
     *
     * @return Une String contenant le type Java (ex : "String")
     *
     * @throws IllegalArgumentException TODO
     */
    public static Class toJavaType(int sqlType) {
        switch (sqlType) {
            case Types.CHAR:
            case Types.VARCHAR:
            case Types.LONGVARCHAR:
                return String.class;
            case Types.SMALLINT:
            case Types.INTEGER:
                return int.class;
            case Types.FLOAT:
                return float.class;
            case Types.DOUBLE:
                return double.class;
            case Types.BIGINT:
                return long.class;
            case Types.NUMERIC:
                return java.math.BigDecimal.class;
            case Types.TIMESTAMP:
                return Timestamp.class;
            case Types.TIME:
                return Time.class;
            case Types.DATE:
                return java.sql.Date.class;
            case Types.BIT:
                return boolean.class;
            default:
                throw new IllegalArgumentException("Type SQL" + " non supporte : "
                    + sqlType);
        }
    }
}