JDBC-元信息

DatabaseMetaData：描述数据库的元数据对象

获取所有数据库

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class MetaDataTest {

    private Connection conn;

    @BeforeEach
    public void start() throws Exception {
        Properties properties = new Properties();
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("jdbc.properties");
        properties.load(in);

        String driver = properties.getProperty("driver");
        String jdbcUrl = properties.getProperty("jdbcUrl");
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");

        Class.forName(driver);

        conn = DriverManager.getConnection(jdbcUrl, user, password);
    }

    @AfterEach
    public void end() throws Exception {
        if (conn != null) {
            conn.close();
        }
    }

    @Test
    public void testGetDatabases(){
        try {
            DatabaseMetaData metaData = conn.getMetaData();
            ResultSet resultSet = metaData.getCatalogs();
            while (resultSet.next()) {
                System.out.println(resultSet.getString("TABLE_CAT"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

获取指定数据库的所有表

@Test
public void testGetTables() {
    try {
        DatabaseMetaData metaData = conn.getMetaData();
        /**
         * "%" 表示任意
         * catalog - 数据库名称；为 null 表示所有
         * schemaPattern - 模式名称；为 null 表示所有
         * tableNamePattern - 表名称
         * types - 表类型，"TABLE"、"VIEW"、"SYSTEM TABLE"、"GLOBAL TEMPORARY"、"LOCAL TEMPORARY"、"ALIAS" 和 "SYNONYM"； null 表示返回所有类型
         */
        ResultSet tablesRS = metaData.getTables("hibernate", "%", "%", new String[]{"TABLE", "VIEW"});
        while (tablesRS.next()) {
            /**
             * TABLE_CAT String => 表类别（可为 null）
             * TABLE_SCHEM String => 表模式（可为 null）
             * TABLE_NAME String => 表名称
             * TABLE_TYPE String => 表类型。典型的类型是 "TABLE"、"VIEW"、"SYSTEM TABLE"、"GLOBAL TEMPORARY"、"LOCAL TEMPORARY"、"ALIAS" 和 "SYNONYM"。
             * REMARKS String => 表的解释性注释
             * TYPE_CAT String => 类型的类别（可为 null）
             * TYPE_SCHEM String => 类型模式（可为 null）
             * TYPE_NAME String => 类型名称（可为 null）
             * SELF_REFERENCING_COL_NAME String => 有类型表的指定 "identifier" 列的名称（可为 null）
             * REF_GENERATION String => 指定在 SELF_REFERENCING_COL_NAME 中创建值的方式。这些值为 "SYSTEM"、"USER" 和 "DERIVED"。（可能为 null）
             */
            System.out.println(tablesRS.getString("TABLE_NAME") + "，" + tablesRS.getString("TABLE_TYPE"));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

获取指定表的所有字段

@Test
public void testGetColumns() {
    try {
        DatabaseMetaData metaData = conn.getMetaData();
        /**
         * "%" 表示任意
         * catalog - 数据库名称；为 null 则表示该类别名称不应该用于缩小搜索范围
         * schemaPattern - 模式名称的模式；它必须与存储在数据库中的模式名称匹配；该参数为 "" 表示获取没有模式的那些描述；为 null 则表示该模式名称不应该用于缩小搜索范围
         * tableNamePattern - 表名称
         * columnNamePattern - 列名称
         */
        ResultSet columnsRS = metaData.getColumns("hibernate", null, "%", null);
        while (columnsRS.next()) {
            /**
             * TABLE_CAT String => 表类别（可为 null）
             * TABLE_SCHEM String => 表模式（可为 null）
             * TABLE_NAME String => 表名称
             * COLUMN_NAME String => 列名称
             * DATA_TYPE int => 来自 java.sql.Types 的 SQL 类型
             * TYPE_NAME String => 数据源依赖的类型名称，对于 UDT，该类型名称是完全限定的
             *
             * COLUMN_SIZE int => 列的大小。
             * * COLUMN_SIZE 列表示给定列的指定列大小。对于数值数据，这是最大精度。对于字符数据，这是字符长度。对于日期时间数据类型，这是 String 表示形式的字符长度（假定允许的最大小数秒组件的精度）。
             * * 对于二进制数据，这是字节长度。对于 ROWID 数据类型，这是字节长度。对于列大小不适用的数据类型，则返回 Null。
             *
             * BUFFER_LENGTH 未被使用。
             * DECIMAL_DIGITS int => 小数部分的位数。对于 DECIMAL_DIGITS 不适用的数据类型，则返回 Null。
             * NUM_PREC_RADIX int => 基数（通常为 10 或 2）
             *
             * NULLABLE int => 是否允许使用 NULL。
             * * columnNoNulls - 可能不允许使用 NULL 值
             * * columnNullable - 明确允许使用 NULL 值
             * * columnNullableUnknown - 不知道是否可使用 null
             *
             * REMARKS String => 描述列的注释（可为 null）
             * COLUMN_DEF String => 该列的默认值，当值在单引号内时应被解释为一个字符串（可为 null）
             * SQL_DATA_TYPE int => 未使用
             * SQL_DATETIME_SUB int => 未使用
             * CHAR_OCTET_LENGTH int => 对于 char 类型，该长度是列中的最大字节数
             * ORDINAL_POSITION int => 表中的列的索引（从 1 开始）
             *
             * IS_NULLABLE String => ISO 规则用于确定列是否包括 null。
             * * YES --- 如果参数可以包括 NULL
             * * NO --- 如果参数不可以包括 NULL
             * * 空字符串 --- 如果不知道参数是否可以包括 null
             *
             * SCOPE_CATLOG String => 表的类别，它是引用属性的作用域（如果 DATA_TYPE 不是 REF，则为 null）
             * SCOPE_SCHEMA String => 表的模式，它是引用属性的作用域（如果 DATA_TYPE 不是 REF，则为 null）
             * SCOPE_TABLE String => 表名称，它是引用属性的作用域（如果 DATA_TYPE 不是 REF，则为 null）
             * SOURCE_DATA_TYPE short => 不同类型或用户生成 Ref 类型、来自 java.sql.Types 的 SQL 类型的源类型（如果 DATA_TYPE 不是 DISTINCT 或用户生成的 REF，则为 null）
             *
             * IS_AUTOINCREMENT String => 指示此列是否自动增加
             * * YES --- 如果该列自动增加
             * * NO --- 如果该列不自动增加
             * * 空字符串 --- 如果不能确定该列是否是自动增加参数
             */
            System.out.println(columnsRS.getString("COLUMN_NAME") + "," + columnsRS.getString("TYPE_NAME")
                    + "," + columnsRS.getString("COLUMN_SIZE")
            );
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

获取指定表的主键

@Test
public void testGetPrimaryKeys() {
    try {
        DatabaseMetaData metaData = conn.getMetaData();
        /**
         * "%" 表示任意
         * catalog - 数据库名称；为 null 则表示该类别名称不应该用于缩小搜索范围
         * schema - 模式名称；它必须与存储在数据库中的模式名称匹配；该参数为 "" 表示获取没有模式的那 些描述；为 null 则表示该模式名称不应该用于缩小搜索范围
         * table - 表名称
         */
        ResultSet primaryKeysRS = metaData.getPrimaryKeys("hibernate", "%", "NEWS");
        while (primaryKeysRS.next()) {
            /**
             * TABLE_CAT String => 表类别（可为 null）
             * TABLE_SCHEM String => 表模式（可为 null）
             * TABLE_NAME String => 表名称
             * COLUMN_NAME String => 列名称
             * KEY_SEQ short => 主键中的序列号（值 1 表示主键中的第一列，值 2 表示主键中的第二列）
             * PK_NAME String => 主键的名称（可为 null）
             */
            System.out.println(primaryKeysRS.getString("COLUMN_NAME") + "，" + primaryKeysRS.getString("PK_NAME"));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

获取指定表的外键

@Test
public void testGetExportedKeys() {
    try {
        DatabaseMetaData metaData = conn.getMetaData();
        /**
         * "%" 表示任意
         * catalog - 数据库名称；为 null 则表示该类别名称不应该用于缩小搜索范围
         * schema - 模式名称；它必须与存储在数据库中的模式名称匹配；该参数为 "" 表示获取没有模式的那 些描述；为 null 则表示该模式名称不应该用于缩小搜索范围
         * table - 表名称
         */
        ResultSet exportedKeysRS = metaData.getExportedKeys("hibernate", "%", "NEWS");
        while (exportedKeysRS.next()) {
            /**
             * PKTABLE_CAT String => 主键表类别（可为 null）
             * PKTABLE_SCHEM String => 主键表模式（可为 null）
             * PKTABLE_NAME String => 主键表名称
             * PKCOLUMN_NAME String => 主键列名称
             * FKTABLE_CAT String => 被导入的外键表类别（可能为 null），该字符串可能为 null
             * FKTABLE_SCHEM String => 被导入的外键表模式（可能为 null），该字符串可能为 null
             * FKTABLE_NAME String => 被导入的外键表名称
             * FKCOLUMN_NAME String => 被导入的外键列名称
             * KEY_SEQ short => 外键中的序列号（值 1 表示外键中的第一列，值 2 表示外键中的第二列）。
             *
             * UPDATE_RULE short => 更新主键时外键发生的变化：
             * * importedNoAction - 如果已经导入，则不允许更新主键
             * * importedKeyCascade - 将导入的键更改为与主键更新一致
             * * importedKeySetNull - 如果已更新导入键的主键，则将导入键更改为 NULL
             * * importedKeySetDefault - 如果已更新导入键的主键，则将导入键更改为默认值
             * * importedKeyRestrict - 与 importedKeyNoAction 相同（为了与 ODBC 2.x 兼容）
             *
             * DELETE_RULE short => 删除主键时外键发生的变化。
             * * importedKeyNoAction - 如果已经导入，则不允许删除主键
             * * importedKeyCascade - 删除导入删除键的行
             * * importedKeySetNull - 如果已删除导入键的主键，则将导入键更改为 NULL
             * * importedKeyRestrict - 与 importedKeyNoAction 相同（为了与 ODBC 2.x 兼容）
             * * importedKeySetDefault - 如果已删除导入键的主键，则将导入键更改为默认值
             *
             * FK_NAME String => 外键的名称（可为 null）
             * PK_NAME String => 主键的名称（可为 null）
             *
             * DEFERRABILITY short => 是否可以将对外键约束的评估延迟到提交时间
             * * importedKeyInitiallyDeferred - 有关定义，请参见 SQL92
             * * importedKeyInitiallyImmediate - 有关定义，请参见 SQL92
             * * importedKeyNotDeferrable - 有关定义，请参见 SQL92
             */
            System.out.println(exportedKeysRS.getString("FKTABLE_NAME") + "，" + exportedKeysRS.getString("FKCOLUMN_NAME"));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

获取数据库信息

@Test
public void testDatabaseMetaData() {
    ResultSet resultSet = null;
    try {
        DatabaseMetaData data = conn.getMetaData();
        // 数据库版本号
        System.out.println(data.getDatabaseProductVersion());
        // 数据库驱动版本号
        System.out.println(data.getDriverVersion());
        // 数据库驱动名称
        System.out.println(data.getDriverName());
        // 连接到数据库的用户名
        System.out.println(data.getUserName());
        // 是否支持事务
        System.out.println(data.supportsTransactions());
        // 连接地址
        System.out.println(data.getURL());
        // 是否处于只读模式
        System.out.println(data.isReadOnly());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

ResultSetMetaData：描述结果集的元数据

@Test
public void testResultSetMetaData() {
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    try {
        String sql = "SELECT *  FROM user";
        preparedStatement = conn.prepareStatement(sql);
        resultSet = preparedStatement.executeQuery();
        ResultSetMetaData rsmd = resultSet.getMetaData();
        // 得到列的个数
        int columnCount = rsmd.getColumnCount();
        System.out.println(columnCount);
        for (int i = 0; i < columnCount; i++) {
            // 得到列名
            String columnName = rsmd.getColumnName(i + 1);
            // 列的别名
            String columnLabel = rsmd.getColumnLabel(i + 1);
            // 列的类型
            String columnType = rsmd.getColumnTypeName(i + 1);
            System.out.println(columnName + ", " + columnLabel + ", " + columnType);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}