Pour répondre spécifiquement "Obtenez le nom du type SQL de java.SQL.Type code", si vous utilisez une version de java qui peut faire de la réflexion, voici une petite méthode utilitaire qui fait à peu près la même chose:

public Map<Integer, String> getAllJdbcTypeNames() {

    Map<Integer, String> result = new HashMap<Integer, String>();

    for (Field field : Types.class.getFields()) {
        result.put((Integer)field.get(null), field.getName());
    }

    return result;
}

Ajoutez import java.lang.reflect.Field; à vos déclarations d'importation. Une fois que vous avez cela en place, utilisez-le simplement comme suit:

...
Map<Integer, String> jdbcMappings = getAllJdbcTypeNames();

String typeName = jdbcMappings.get(-5); // now that will return BIGINT
...

Java 8 et versions ultérieures: JDBCType & SQLType

, Avec des améliorations de l'API de Java 8 et JDBC 4.2, nous avons JDBCType et SQLType, et dans le même esprit que d'autres exemples peut être utilisé simplement comme suit:

String typeName = JDBCType.valueOf(-5).getName();

, Mais bien sûr, pourquoi utiliser les types numériques pour commencer. Prenez une habitude et passez des valeurs numériques aux constantes enum définies dans JDBCType:

String typeName = JDBCType.BIGINT.getName();

Et voilà!

Cependant, cela pourrait ne pas suffire pour avoir quelque chose d'assez bon pour l'utilisation dans un DDL ... vous devrez peut-être implémenter une traduction spécifique au fournisseur. Par exemple, vous devrez peut-être envisager de traduire VARCHAR en VARCHAR2 dans le cas d'Oracle.

public static String getSqlTypeName(int type) {
    switch (type) {
    case Types.BIT:
        return "BIT";
    case Types.TINYINT:
        return "TINYINT";
    case Types.SMALLINT:
        return "SMALLINT";
    case Types.INTEGER:
        return "INTEGER";
    case Types.BIGINT:
        return "BIGINT";
    case Types.FLOAT:
        return "FLOAT";
    case Types.REAL:
        return "REAL";
    case Types.DOUBLE:
        return "DOUBLE";
    case Types.NUMERIC:
        return "NUMERIC";
    case Types.DECIMAL:
        return "DECIMAL";
    case Types.CHAR:
        return "CHAR";
    case Types.VARCHAR:
        return "VARCHAR";
    case Types.LONGVARCHAR:
        return "LONGVARCHAR";
    case Types.DATE:
        return "DATE";
    case Types.TIME:
        return "TIME";
    case Types.TIMESTAMP:
        return "TIMESTAMP";
    case Types.BINARY:
        return "BINARY";
    case Types.VARBINARY:
        return "VARBINARY";
    case Types.LONGVARBINARY:
        return "LONGVARBINARY";
    case Types.NULL:
        return "NULL";
    case Types.OTHER:
        return "OTHER";
    case Types.JAVA_OBJECT:
        return "JAVA_OBJECT";
    case Types.DISTINCT:
        return "DISTINCT";
    case Types.STRUCT:
        return "STRUCT";
    case Types.ARRAY:
        return "ARRAY";
    case Types.BLOB:
        return "BLOB";
    case Types.CLOB:
        return "CLOB";
    case Types.REF:
        return "REF";
    case Types.DATALINK:
        return "DATALINK";
    case Types.BOOLEAN:
        return "BOOLEAN";
    case Types.ROWID:
        return "ROWID";
    case Types.NCHAR:
        return "NCHAR";
    case Types.NVARCHAR:
        return "NVARCHAR";
    case Types.LONGNVARCHAR:
        return "LONGNVARCHAR";
    case Types.NCLOB:
        return "NCLOB";
    case Types.SQLXML:
        return "SQLXML";
    }

    return "?";
}

Vous avez besoin de la ResultSetMetaData objet de votre ResultSet. Vous pouvez l'obtenir avec getMetaData(). Itérer sur les colonnes et appeler foreach colonne la méthode

1. getColumnType(i)
2. getColumnClassName(i)
3. getColumnTypeName(i)

De votre ResultSetMetaData.

i représente le numéro de colonne (commençant par 1).

Spring a une énumération d'aide pratique appelée JdbcTypesEnum, mais il est en effet assez étrange que cela ne fasse pas partie de JDBC proprement dit. Cependant, au lieu d'utiliser

rs = connection.getMetaData().getColumns();
...
int dataType = rs.getInt("DATA_TYPE");

J'utiliserais

String typeName = rs.getString("TYPE_NAME");

Lors de la récupération du type de colonne. Par exemple lors de l'inspection d'un H2 base de données table avec un spécial VARCHAR_IGNORECASE ou UUID type:

                    dataType   vs. typeName
UUID:               -2=BINARY  vs. "UUID"
VARCHAR_IGNORECASE: 12=VARCHAR vs. "VARCHAR_IGNORECASE"

Mais notez que vous ne pouvez pas couvrir la plage de types de la chaîne pour toutes les bases de données, dans ce cas, l'int serait un peu plus pratique (mais ce n'est après tout pas un type d'énumération fermé).

La bibliothèque Apache DdlUtils a une classe de commodité pour cela: https://db.apache.org/ddlutils/api/org/apache/ddlutils/model/TypeMap.html

String typeName = TypeMap.getJdbcTypeName(typeCode)

La bibliothèque vous aide également avec d'autres besoins DDL, mais ne semble pas attirer beaucoup d'attention ces derniers temps.

Je cherchais également SqlType et je l'ai trouvé dans ce code source
http://www.docjar.com/html/api/java/sql/Types.java.html