types.java

hsql是很有名的嵌入式数据库

    static final int SQL_XML              = 137;

    // SQL_UDT subcodes
    static final int SQL_DISTINCT    = 1;
    static final int SQL_SCTRUCTURED = 2;

    // non-standard type not in JDBC or SQL CLI
    public static final int VARCHAR_IGNORECASE = 100;

// lookup for types
// boucherb@users - access changed for metadata 1.7.2
    static IntValueHashMap typeAliases;
    static IntKeyHashMap   typeNames;
    static IntValueHashMap javaTypeNames;

//  boucherb@users - We can't handle method invocations in
//                   Function.java whose number class is
//                   narrower than the corresponding internal
//                   wrapper
    private static org.hsqldb.lib.HashSet illegalParameterClasses;

    static {
        typeAliases = new IntValueHashMap(67, 1);

        typeAliases.put("INTEGER", Types.INTEGER);
        typeAliases.put("INT", Types.INTEGER);
        typeAliases.put("int", Types.INTEGER);
        typeAliases.put("java.lang.Integer", Types.INTEGER);
        typeAliases.put("IDENTITY", Types.INTEGER);
        typeAliases.put("DOUBLE", Types.DOUBLE);
        typeAliases.put("double", Types.DOUBLE);
        typeAliases.put("java.lang.Double", Types.DOUBLE);
        typeAliases.put("FLOAT", Types.FLOAT);
        typeAliases.put("REAL", Types.REAL);
        typeAliases.put("VARCHAR", Types.VARCHAR);
        typeAliases.put("java.lang.String", Types.VARCHAR);
        typeAliases.put("CHAR", Types.CHAR);
        typeAliases.put("CHARACTER", Types.CHAR);
        typeAliases.put("LONGVARCHAR", Types.LONGVARCHAR);
        typeAliases.put("VARCHAR_IGNORECASE", VARCHAR_IGNORECASE);
        typeAliases.put("DATE", Types.DATE);
        typeAliases.put(DateClassName, Types.DATE);
        typeAliases.put("TIME", Types.TIME);
        typeAliases.put(TimeClassName, Types.TIME);
        typeAliases.put("TIMESTAMP", Types.TIMESTAMP);
        typeAliases.put(TimestampClassName, Types.TIMESTAMP);
        typeAliases.put("DATETIME", Types.TIMESTAMP);
        typeAliases.put("DECIMAL", Types.DECIMAL);
        typeAliases.put(DecimalClassName, Types.DECIMAL);
        typeAliases.put("NUMERIC", Types.NUMERIC);
        typeAliases.put("BIT", Types.BOOLEAN);
        typeAliases.put("BOOLEAN", Types.BOOLEAN);
        typeAliases.put("boolean", Types.BOOLEAN);
        typeAliases.put("java.lang.Boolean", Types.BOOLEAN);
        typeAliases.put("TINYINT", Types.TINYINT);
        typeAliases.put("byte", Types.TINYINT);
        typeAliases.put("java.lang.Byte", Types.TINYINT);
        typeAliases.put("SMALLINT", Types.SMALLINT);
        typeAliases.put("short", Types.SMALLINT);
        typeAliases.put("java.lang.Short", Types.SMALLINT);
        typeAliases.put("BIGINT", Types.BIGINT);
        typeAliases.put("long", Types.BIGINT);
        typeAliases.put("java.lang.Long", Types.BIGINT);
        typeAliases.put("BINARY", Types.BINARY);
        typeAliases.put("[B", Types.BINARY);
        typeAliases.put("VARBINARY", Types.VARBINARY);
        typeAliases.put("LONGVARBINARY", Types.LONGVARBINARY);
        typeAliases.put("OTHER", Types.OTHER);
        typeAliases.put("OBJECT", Types.OTHER);
        typeAliases.put("java.lang.Object", Types.OTHER);
        typeAliases.put("NULL", Types.NULL);
        typeAliases.put("void", Types.NULL);
        typeAliases.put("java.lang.Void", Types.NULL);

        //
        typeNames = new IntKeyHashMap(37);

        typeNames.put(Types.NULL, "NULL");
        typeNames.put(Types.INTEGER, "INTEGER");
        typeNames.put(Types.DOUBLE, "DOUBLE");
        typeNames.put(VARCHAR_IGNORECASE, "VARCHAR_IGNORECASE");
        typeNames.put(Types.VARCHAR, "VARCHAR");
        typeNames.put(Types.CHAR, "CHAR");
        typeNames.put(Types.LONGVARCHAR, "LONGVARCHAR");
        typeNames.put(Types.DATE, "DATE");
        typeNames.put(Types.TIME, "TIME");
        typeNames.put(Types.DECIMAL, "DECIMAL");
        typeNames.put(Types.BOOLEAN, "BOOLEAN");
        typeNames.put(Types.TINYINT, "TINYINT");
        typeNames.put(Types.SMALLINT, "SMALLINT");
        typeNames.put(Types.BIGINT, "BIGINT");
        typeNames.put(Types.REAL, "REAL");
        typeNames.put(Types.FLOAT, "FLOAT");
        typeNames.put(Types.NUMERIC, "NUMERIC");
        typeNames.put(Types.TIMESTAMP, "TIMESTAMP");
        typeNames.put(Types.BINARY, "BINARY");
        typeNames.put(Types.VARBINARY, "VARBINARY");
        typeNames.put(Types.LONGVARBINARY, "LONGVARBINARY");
        typeNames.put(Types.OTHER, "OBJECT");

        //
        illegalParameterClasses = new org.hsqldb.lib.HashSet(13);

        illegalParameterClasses.add(Byte.TYPE);
        illegalParameterClasses.add(Short.TYPE);
        illegalParameterClasses.add(Float.TYPE);
        illegalParameterClasses.add(Byte.class);
        illegalParameterClasses.add(Short.class);
        illegalParameterClasses.add(Float.class);
    }

    /**
     *
     * @param type string
     * @return java.sql.Types int value
     * @throws  HsqlException
     */
    static int getTypeNr(String type) throws HsqlException {

        int i = typeAliases.get(type, Integer.MIN_VALUE);

        Trace.check(i != Integer.MIN_VALUE, Trace.WRONG_DATA_TYPE, type);

        return i;
    }

    /**
     * Returns SQL type string for a java.sql.Types int value
     */
    public static String getTypeString(int type) {
        return (String) typeNames.get(type);
    }

    /**
     * Returns SQL type string for a java.sql.Types int value
     */
    public static String getTypeString(int type, int precision, int scale) {

        String s = (String) typeNames.get(type);

        if (precision != 0 && acceptsPrecisionCreateParam(type)) {
            StringBuffer sb = new StringBuffer(s);

            sb.append(Token.T_OPENBRACKET);
            sb.append(precision);

            if (scale != 0 && acceptsScaleCreateParam(type)) {
                sb.append(Token.T_COMMA);
                sb.append(scale);
            }

            sb.append(Token.T_CLOSEBRACKET);

            return sb.toString();
        }

        return s;
    }

    /**
     * Retieves the type number corresponding to the class
     * of an IN, IN OUT or OUT parameter.  <p>
     *
     * This method extends getTypeNr to return OTHER for
     * primitive arrays, classes that directly implement
     * java.io.Serializable and non-primitive arrays whose
     * base component implements java.io.Serializable,
     * allowing, for instance, arguments and return types of
     * primitive arrays, Serializable objects and arrays,
     * of Serializable objects.  Direct primitive types
     * other than those mapping directly to the internal
     * wrapper form are not yet handled.  That is, HSQLDB
     * cannot yet properly deal with CALLs involving methods
     * with primitive byte, short, float or their
     * corresponding wrappers, due to the way internal
     * conversion works and lack of detection and narrowing
     * code in Function to allow this.  In other words,
     * passing in or retrieving any of the mentioned types
     * always causes conversion to a wider internal wrapper
     * which is genrally incompatible under reflective
     * invocation, resulting in an IllegalArgumentException.
     *
     * @param  c a Class instance
     * @return java.sql.Types int value
     * @throws  HsqlException
     */
    static int getParameterTypeNr(Class c) throws HsqlException {

        String name;
        int    type;

        if (c == null) {
            Trace.doAssert(false, "c is null");
        }

        if (Void.TYPE.equals(c)) {
            return Types.NULL;
        }

        if (illegalParameterClasses.contains(c)) {
            throw Trace.error(Trace.WRONG_DATA_TYPE,
                              Trace.UNSUPPORTED_PARAM_CLASS, c.getName());
        }

        name = c.getName();
        type = typeAliases.get(name, Integer.MIN_VALUE);

        if (type == Integer.MIN_VALUE) {

            // byte[] is already covered as BINARY in typeAliases
            if (c.isArray()) {
                while (c.isArray()) {
                    c = c.getComponentType();
                }

                if (c.isPrimitive()
                        || java.io.Serializable.class.isAssignableFrom(c)) {
                    type = OTHER;
                }
            } else if (java.io.Serializable.class.isAssignableFrom(c)) {
                type = OTHER;
            }
        }

        Trace.check(type != Integer.MIN_VALUE, Trace.WRONG_DATA_TYPE, name);

        return type;
    }

/*
    static boolean areSimilar(int t1, int t2) {

        if (t1 == t2) {
            return true;
        }

        if (isNumberType(t1)) {
            return isNumberType(t2);
        }

        if (isCharacterType(t1)) {
            return isCharacterType(t2);
        }

        if (isBinaryType(t1)) {
            return isBinaryType(t2);
        }

        return false;
    }

    static boolean haveSameInternalRepresentation(int t1, int t2) {

        if (t1 == t2) {
            return true;
        }

        if (isCharacterType(t1)) {
            return isCharacterType(t2);
        }

        if (isBinaryType(t1)) {
            return isBinaryType(t2);
        }

        switch (t1) {

            case TINYINT :
            case SMALLINT :
            case INTEGER : {
                switch (t2) {

                    case TINYINT :
                    case SMALLINT :
                    case INTEGER : {
                        return true;
                    }
                    default : {
                        return false;
                    }
                }
            }
            case FLOAT :
            case REAL :
            case DOUBLE : {
                switch (t2) {

                    case FLOAT :
                    case REAL :
                    case DOUBLE : {
                        return true;
                    }
                    default : {
                        return false;
                    }
                }
            }
            case DECIMAL :
            case NUMERIC : {
                switch (t2) {

                    case DECIMAL :
                    case NUMERIC : {
                        return true;
                    }
                    default : {
                        return false;
                    }
                }
            }
            default : {
                return false;
            }
        }
    }

    static boolean isExactNumberType(int type) {

        switch (type) {

            case BIGINT :
            case DECIMAL :
            case INTEGER :
            case NUMERIC :
            case SMALLINT :
            case TINYINT :
                return true;

            default :
                return false;
        }
    }

    static boolean isStrictlyIntegralNumberType(int type) {

        switch (type) {

            case BIGINT :
            case INTEGER :
            case SMALLINT :
            case TINYINT :
                return true;

            default :
                return false;
        }
    }

    static boolean isApproximateNumberType(int type) {

        switch (type) {

            case DOUBLE :
            case FLOAT :
            case REAL :
                return true;

            default :
                return false;
        }
    }

    public static boolean isBinaryType(int type) {

        switch (type) {

            case BINARY :

            case BLOB :
            case LONGVARBINARY :
            case VARBINARY :
                return true;

            default :
                return false;
        }
    }

*/
    static boolean isDatetimeType(int type) {

        switch (type) {

            case DATE :
            case TIME :
            case TIMESTAMP :
                return true;

            default :
                return false;
        }
    }

    /**
     * Types that accept precition params in column definition or casts.
     * We ignore the parameter in many cases but accept it for compatibility
     * with other engines. CHAR, VARCHAR and VARCHAR_IGNORECASE params
     * are used when the sql.enforce_strict_types is true.
     *
     */
    public static boolean acceptsPrecisionCreateParam(int type) {

        switch (type) {

            case BINARY :
            case BLOB :
            case CHAR :
            case CLOB :

            //            case LONGVARBINARY :
            //            case LONGVARCHAR :
            case VARBINARY :
            case VARCHAR :
            case VARCHAR_IGNORECASE :
            case DECIMAL :
            case NUMERIC :
            case FLOAT :
            case TIMESTAMP :
                return true;

            default :
                return false;
        }
    }

    public static int numericPrecisionCreateParamRadix(int type) {

        switch (type) {

            case Types.DECIMAL :
            case Types.NUMERIC :
                return 10;

            case FLOAT :
                return 2;

            default :

                // to mean NOT APPLICABLE (i.e. NULL)
                return 0;
        }
    }

    public static boolean acceptsScaleCreateParam(int type) {