IT数码 购物 网址 头条 软件 日历 阅读 图书馆
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
图片批量下载器
↓批量下载图片,美女图库↓
图片自动播放器
↓图片自动播放器↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁
 
   -> 开发工具 -> jdbc元数据DataBaseMetaData查询数据库表信息详解 -> 正文阅读

[开发工具]jdbc元数据DataBaseMetaData查询数据库表信息详解

使用jdbc驱动的元数据metaData获取指定数据库的表信息和表字段信息。

测试请求:http://localhost:30001/api/tableInfoQuery/queryTableInfos

测试数据:{“dataSourceUrl”: “jdbc:mysql://192.168.51.1:3306/yusp_plus_real_xs?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true”,“userName”: “root”,“passWord”: “123456”}

测试时请更改数据库链接配置信息。

下面代码不全,需要补充下contrller入口调用类、TableInfoQueyVO实体对象。这里只是写了实现方法

package cn.com.yusys.yusp.base.data.service.impl;

import cn.com.yusys.yusp.base.data.domain.vo.TableInfoQueyVO;
import cn.com.yusys.yusp.base.data.service.TableInfoQueryService;
import cn.com.yusys.yusp.commons.util.StringUtils;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.util.*;

/**
 * @DATE 2022/4/24 10:04
 * @USER luofeng
 * @NAME TableInfoQueryServiceImpl
 * @VERSION 1.0.0_V
 * @DESC
 */
@Slf4j
@Service("tableInfoQueryService")
public class TableInfoQueryServiceImpl implements TableInfoQueryService {
    @Override
    public List<TableInfoQueyVO> getTableFieldInfo(String dataInfo) throws Exception {

        Map<String,String> dataSourceInfos = (Map<String, String>) JSON.parse(dataInfo);
        String dataSourceUrl = dataSourceInfos.get("dataSourceUrl");
        if (StringUtils.isBlank(dataSourceUrl)){
            throw new Exception("数据源信息为空!");
        }
        String userName = dataSourceInfos.get("userName");
        if (StringUtils.isBlank(userName)){
            throw new Exception("该用户信息为空!");
        }
        String passWord = dataSourceInfos.get("passWord");
        if (StringUtils.isBlank(passWord)){
            throw new Exception("该用户密码为空!");
        }
        String tableName = dataSourceInfos.get("tableName");
        if (StringUtils.isBlank(tableName)){
            throw new Exception("查询表名不能为空!");
        }
        Connection conn = getDataSourceConn(dataSourceUrl,userName,passWord);
        log.info("-------数据源初始化结束------");
        //获取链接元数据信息。
        DatabaseMetaData metaData = conn.getMetaData();

        List<TableInfoQueyVO> tableFields = this.getTableFields(metaData, tableName,dataSourceUrl,userName);
        return tableFields;
    }

    @Override
    public List<Map<String, String>> getTableListInfo(String dataSourceInfo) throws Exception {

        Map<String,String> dataSourceInfos = (Map<String, String>) JSON.parse(dataSourceInfo);
        String dataSourceUrl = dataSourceInfos.get("dataSourceUrl");
        if (StringUtils.isBlank(dataSourceUrl)){
            throw new Exception("数据源信息为空!");
        }
        String userName = dataSourceInfos.get("userName");
        if (StringUtils.isBlank(userName)){
            throw new Exception("该用户信息为空!");
        }
        String passWord = dataSourceInfos.get("passWord");
        if (StringUtils.isBlank(passWord)){
            throw new Exception("该用户密码为空!");
        }

        log.info("开始查询数据源{}-{}-{},信息",dataSourceUrl,userName,passWord);

        Connection conn = getDataSourceConn(dataSourceUrl,userName,passWord);
        log.info("-------数据源初始化结束------");
        //获取链接元数据信息。
        DatabaseMetaData metaData = conn.getMetaData();

        List<Map<String, String>> tableList = this.getTableInfoList(metaData,dataSourceUrl,userName);

        closeConnection(conn);

        return tableList;
    }

    /**
     * 根据数据源 获取改数据源下说有的表结构信息。
     *
     * @param dataSourceInfo
     * @return
     */
    @Override
    public List<Map<String, Object>> getTableInfos(String dataSourceInfo) throws Exception{

        Map<String,String> dataSourceInfos = (Map<String, String>) JSON.parse(dataSourceInfo);
        String dataSourceUrl = dataSourceInfos.get("dataSourceUrl");
        if (StringUtils.isBlank(dataSourceUrl)){
            throw new Exception("数据源信息为空!");
        }
        String userName = dataSourceInfos.get("userName");
        if (StringUtils.isBlank(userName)){
            throw new Exception("该用户信息为空!");
        }
        String passWord = dataSourceInfos.get("passWord");
        if (StringUtils.isBlank(passWord)){
            throw new Exception("该用户密码为空!");
        }

        log.info("开始查询数据源{},信息",dataSourceUrl,userName,passWord);
        List<Map<String,Object>> listInfos = new ArrayList<>();

        Connection conn = getDataSourceConn(dataSourceUrl,userName,passWord);
        log.info("-------数据源初始化结束------");
        //获取链接元数据信息。
        DatabaseMetaData metaData = conn.getMetaData();
        List<Map<String, String>> tableList = this.getTableList(metaData,dataSourceUrl,userName);

        for (Map<String, String> stringMap : tableList) {
            Map<String,Object> tableInfoMap = new HashMap<>();
            for (String ss : stringMap.keySet()) {
                tableInfoMap.put("tableName",ss);
                List<TableInfoQueyVO> tableFields = this.getTableFields(metaData, ss,dataSourceUrl,userName);
                tableInfoMap.put("tableFields",tableFields);
            }
            listInfos.add(tableInfoMap);
        }
        //关闭链接
        closeConnection(conn);
        log.info("查询数据源信息处理结束!");
        return listInfos;
    }

    /**
     * 获取数据库 链接
     * @param dataSourceUrl
     * @param userName
     * @param passWord
     * @return
     * @throws Exception
     */
    public Connection getDataSourceConn(String dataSourceUrl,String userName,String passWord) throws Exception{
        log.info("-------数据源初始化开始------");
        Properties pros = new Properties();
        pros.setProperty("user",userName);
        pros.setProperty("password",passWord);
        pros.setProperty("remarks","true");
        if (dataSourceUrl.contains("mysql")){
          //需要加入个可以获取 REMARKS 的信息,不然获取到的为空
            pros.setProperty("useInformationSchema","true");
            Class.forName("com.mysql.cj.jdbc.Driver").newInstance();
        }else if (dataSourceUrl.contains("oracle")){
            Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
        }else {
            throw new Exception("不支持的数据类型");
        }

//        DriverManager.getConnection(dataSourceUrl,userName,passWord);
        return DriverManager.getConnection(dataSourceUrl,pros);

    }

    /**
     * 获取该数据源下 所有的列表
     * @param metaData
     * @param dataSourceUrl
     * @return
     * @throws Exception
     */
    public List<Map<String,String>> getTableList(DatabaseMetaData metaData,String dataSourceUrl,String userName) throws Exception{

        log.info("-------获取数据库表 列表开始---------");
        List<Map<String,String>> tableInfoList = new ArrayList<>();

        String dataBaseName = null;
        if (dataSourceUrl.contains("mysql")){
            dataBaseName =dataSourceUrl.substring(dataSourceUrl.lastIndexOf("/")+1,dataSourceUrl.indexOf("?"));
            userName = null;
        }

        ResultSet tables = metaData.getTables(dataBaseName, userName, "%", new String[]{"TABLE"});

        while (tables.next()){
            Map<String,String> tableInfoMap = new HashMap<>();
            tableInfoMap.put(tables.getString("TABLE_NAME"),tables.getString("REMARKS"));
            tableInfoList.add(tableInfoMap);
        }
        //打印测试表
        log.info("-------获取数据库表 列表结束---------");
        return tableInfoList;
    }

    /**
     * 获取表中,所有的表的字段
     * @param metaData
     * @param tableName
     * @param dataSourceUrl
     * @return
     * @throws Exception
     */
    public List<TableInfoQueyVO> getTableFields(DatabaseMetaData metaData,String tableName,String dataSourceUrl,String userName) throws Exception{
        List<TableInfoQueyVO> tableFieldList = new ArrayList<>();
				//兼容oracle和mysql
        String dataBaseName = null;
        if (dataSourceUrl.contains("mysql")){
            dataBaseName =dataSourceUrl.substring(dataSourceUrl.lastIndexOf("/")+1,dataSourceUrl.indexOf("?"));
            userName = null;
        }
        //mysql 使用dataBaseName ,oracle 使用 userName
        ResultSet dataColumns = metaData.getColumns(dataBaseName, userName, tableName, "%");
        ResultSet keys = metaData.getPrimaryKeys(dataBaseName, null, tableName);

        Object entityInstance = this.getEntityInstance(getClassNameList(tableName));

        Map<String,String> breakMap = new HashMap<>();
         while(null!=dataColumns&&dataColumns.next()){
            TableInfoQueyVO tiqv = new TableInfoQueyVO();
            if (!StringUtils.isEmpty(breakMap.get(dataColumns.getString("COLUMN_NAME")))){
                break;
            }

            breakMap.put(dataColumns.getString("COLUMN_NAME"),dataColumns.getString("TYPE_NAME"));
             //比较字段值
            if (this.compareFieldType(dataColumns.getString("COLUMN_NAME"),
                     dataColumns.getString("TYPE_NAME"),entityInstance)){
                 tiqv.setFieldType(dataColumns.getString("TYPE_NAME"));
            }
            tiqv.setFieldCode(dataColumns.getString("COLUMN_NAME"));
            tiqv.setFieldName(dataColumns.getString("REMARKS"));
//            tiqv.setFieldType(dataColumns.getString("TYPE_NAME"));

            String primaryKey = null;
            if (null!=keys&&keys.next()){
                primaryKey = keys.getString("COLUMN_NAME");
                String primaryKeyType = keys.getString("PK_NAME");
                if ("PRIMARY".equals(primaryKeyType)&&primaryKey.equals(tiqv.getFieldCode())){
                    tiqv.setIsKey(primaryKey);
                }

            }
            tableFieldList.add(tiqv);
        }
        breakMap.clear();
        return tableFieldList;
    }

    /**
     * 关闭链接
     * @param conn
     * @throws Exception
     */
    public void closeConnection(Connection conn) throws Exception{
        if (conn.isClosed()){
            log.info("数据源链接已关闭!");
            return;
        }else {
            conn.close();
            log.info("数据源链接关闭结束");
        }
    }

    /**
     * 获取实体对象实例
     * @param className
     * @return
     * @throws Exception
     */
    public Object getEntityInstance(List<String> className) throws Exception{

        Class<?> aClass;

        for (String s : className) {
            try {
                aClass = Class.forName(s);
            } catch (ClassNotFoundException e) { //如果是不存在的地址,继续
                continue;
            }
            if (null != aClass){
                return aClass.newInstance();
            }
        }
        return null;
    }

    /**
     * 获取 实例所在的地址
     * @param tableName
     * @return
     */
    public List<String> getClassNameList(String tableName){

        //新增工程目录需要在这里新增 entity 路径
        List<String> classPathList = new ArrayList<>();
        classPathList.add("cn.com.yusys.yusp.base.data.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.base.engine.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.data.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.message.entity.");
        classPathList.add("cn.com.yusys.yusp.notice.entity.");
        classPathList.add("cn.com.yusys.yusp.oca.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.strategy.data.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.strategy.engine.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.strategy.manager.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.stream.engine.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.stream.manager.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.untiy.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.warning.data.domain.entity.");
        classPathList.add("cn.com.yusys.yusp.warning.engine.domain.entity.");

        List<String> classPathContent = new ArrayList<>();

        String[] split = tableName.split("_");
        String tableNameTmpA = "";
        //实体类类型拼接
        for (String s : split) {
            tableNameTmpA = tableNameTmpA+org.apache.commons.lang.StringUtils.capitalize(s);
        }
        String tableNameTmpB = "";
        for (int i = 1; i < split.length; i++) {
            tableNameTmpB = tableNameTmpB+org.apache.commons.lang.StringUtils.capitalize(split[i]);
        }
        //组装成全路径,并保存,因为不确定 entity 到底是那种,所有两种都组装
        for (String s : classPathList) {
            classPathContent.add(s+tableNameTmpA+"Entity");
            classPathContent.add(s+tableNameTmpA+"Entity");
        }

        return classPathContent;

    }

    /**
     * 比较数据库中字段类型和实体类中的类型是否一致
     * @param fieldName
     * @param fieldType
     * @param entityInstance
     * @return
     */
    public boolean compareFieldType(String fieldName,String fieldType,Object entityInstance){

        if (org.springframework.util.StringUtils.isEmpty(entityInstance)){
            return true;
        }
        Field[] declaredFields = entityInstance.getClass().getDeclaredFields();
        if (org.springframework.util.StringUtils.isEmpty(declaredFields)){
            return false;
        }
        String[] split = fieldName.split("_");
        String fieldNameTmp = split[0].toLowerCase();
        for (int i = 1; i < split.length; i++) {
            fieldNameTmp = fieldNameTmp+org.apache.commons.lang.StringUtils.capitalize(split[i].toLowerCase());
        }

        for (Field declaredField : declaredFields) {
            //字段为空 继续下次循环
            if (org.springframework.util.StringUtils.isEmpty(declaredField)){
                continue;
            }
            //未知数据类型
            if (StringUtils.isBlank(FieldTypeRef.getRefTypeCode(fieldType))){
                return false;
            }
            //如果字段名一致,且字段在映射项中
            if (fieldNameTmp.equals(declaredField.getName())
                    &&declaredField.getType().getName().contains(FieldTypeRef.getRefTypeCode(fieldType))){
                return true;
            }

        }
        return false;
    }
    public List<Map<String,String>> getTableInfoList(DatabaseMetaData metaData,String dataSourceUrl,String userName) throws Exception{

        log.info("-------获取数据库表 列表开始---------");
        List<Map<String,String>> tableInfoList = new ArrayList<>();

        String dataBaseName = null;
        if (dataSourceUrl.contains("mysql")){
            dataBaseName =dataSourceUrl.substring(dataSourceUrl.lastIndexOf("/")+1,dataSourceUrl.indexOf("?"));
            userName = null;
        }

        ResultSet tables = metaData.getTables(dataBaseName, userName, "%", new String[]{"TABLE"});

        while (tables.next()){
            Map<String,String> tableInfoMap = new HashMap<>();
            tableInfoMap.put("tableCode",tables.getString("TABLE_NAME"));
            tableInfoMap.put("tableName",tables.getString("REMARKS"));
            tableInfoList.add(tableInfoMap);

        }
        //打印测试表
        log.info("-------获取数据库表 列表结束---------");
        return tableInfoList;
    }
}

/**
 * 字段类型枚举类
 */
enum FieldTypeRef{

    VAR("VARCHAR","String"),
    TEXT("TEXT","String"),
    INT("INT","Integer"),
    DATETIME("DATETIME","Date"),
    CHAR("CHAR","String"),
    DECIMAL("DECIMAL","BigDecimal"),
    FLOAT("FLOAT","float")
    ;

    private String typeCode;
    private String refTypeCoe;

    public String getTypeCode() {
        return typeCode;
    }

    public void setTypeCode(String typeCode) {
        this.typeCode = typeCode;
    }

    public String getRefTypeCoe() {
        return refTypeCoe;
    }

    public void setRefTypeCoe(String refTypeCoe) {
        this.refTypeCoe = refTypeCoe;
    }

    FieldTypeRef(String typeCode, String refTypeCoe) {
        this.typeCode = typeCode;
        this.refTypeCoe = refTypeCoe;
    }

    public static String getRefTypeCode(String key){

        for (FieldTypeRef value : FieldTypeRef.values()) {
            if (key.equals(value.typeCode)){
                return value.getRefTypeCoe();
            }
        }
        return null;
    }
}

getTables

检索给定目录中可用表的描述。仅返回与目录、模式、表名称和类型条件匹配的表描述。它们按 TABLE_TYPE、TABLE_CAT、TABLE_SCHEM 和 TABLE_NAME 排序。

/**
     * 检索给定目录中可用表的描述。
     * 只有与目录、模式、表匹配的表描述
     * 返回名称和类型标准。他们被订购
     * <code>TABLE_TYPE</code>, <code>TABLE_CAT</code>,
     * <code>TABLE_SCHEM</code> 和 <code>TABLE_NAME</code>。
     * <P>
     * 每个表描述都有以下列:
     * <OL>
     * <LI><B>TABLE_CAT</B> String {@code =>} 表目录(可能是<code>null</code>)
     * <LI><B>TABLE_SCHEM</B> 字符串 {@code =>} 表模式(可能是 <code>null</code>)
     * <LI><B>TABLE_NAME</B> 字符串 {@code =>} 表名
     * <LI><B>TABLE_TYPE</B> 字符串 {@code =>} 表类型。典型的类型是“TABLE”,
     *“视图”、“系统表”、“全局临时”、
     *“本地临时”、“别名”、“同义词”。
     * <LI><B>REMARKS</B> String {@code =>} 对表格的解释性注释
     * <LI><B>TYPE_CAT</B> String {@code =>} 类型目录(可能是<code>null</code>)
     * <LI><B>TYPE_SCHEM</B> String {@code =>} 类型模式(可能是 <code>null</code>)
     * <LI><B>TYPE_NAME</B> String {@code =>} 类型名称(可能是<code>null</code>)
     * <LI><B>SELF_REFERENCING_COL_NAME</B> String {@code =>} 指定名称
     * 类型表的“标识符”列(可能是 <code>null</code>)
     * <LI><B>REF_GENERATION</B> String {@code =>} 指定值如何在
     * 创建 SELF_REFERENCING_COL_NAME。值为
     *“系统”、“用户”、“派生”。 (可能是 <code>null</code>)
     * </OL>
     *
     * <P><B>注意:</B>有些数据库可能不会返回信息
     * 所有表格。
     *
     * @param catalog 一个目录名;必须与目录名称匹配
     * 存储在数据库中; "" 检索那些没有目录的;
     * <code>null</code> 表示不应该使用目录名称来缩小搜索
     * @param schemaPattern 模式名称模式;必须与架构名称匹配
     * 因为它存储在数据库中; "" 检索那些没有模式的;
     * <code>null</code> 表示不应该使用模式名称来缩小范围搜索
     * @param tableNamePattern 一个表名模式;必须匹配存储在数据库中的表名
     * @param types 表类型列表,必须来自表类型列表
     * 从 {@link #getTableTypes} 返回,包括; <code>null</code> 返回所有类型
     * @return <code>ResultSet</code> - 每行是一个表描述
     * @exception SQLException 如果发生数据库访问错误
     * @see #getSearchStringEscape
     */

参数:

? String catalog: mysql下就是数据库名称,oracle下就是instance名;可以为null,可以为“”。解释参见@param catalog

? String schemaPattern:mysql下就是数据库名称,oracle中就是用户名.解释参见@param schemaPattern

? String tableNamePattern: 数据表名称

? String[] types: 查询的表类型,参考注解中的解释

getColumns

 /**
     * 检索可用的表列的描述
     * 指定目录。
     *
     * <P>只有与目录、模式、表匹配的列描述
     * 和列名条件被返回。他们被订购
     * <code>TABLE_CAT</code>,<code>TABLE_SCHEM</code>,
     * <code>TABLE_NAME</code> 和 <code>ORDINAL_POSITION</code>。
     *
     * <P>每列描述都有以下列:
     * <OL>
     * <LI><B>TABLE_CAT</B> String {@code =>} 表目录(可能是<code>null</code>)
     * <LI><B>TABLE_SCHEM</B> 字符串 {@code =>} 表模式(可能是 <code>null</code>)
     * <LI><B>TABLE_NAME</B> 字符串 {@code =>} 表名
     * <LI><B>COLUMN_NAME</B> 字符串 {@code =>} 列名
     * <LI><B>DATA_TYPE</B> int {@code =>} 来自 java.sql.Types 的 SQL 类型
     * <LI><B>TYPE_NAME</B> String {@code =>} 数据源依赖类型名称,
     * 对于 UDT,类型名称是完全限定的
     * <LI><B>COLUMN_SIZE</B> int {@code =>} 列大小。
     * <LI><B>BUFFER_LENGTH</B> 未使用。
     * <LI><B>DECIMAL_DIGITS</B> int {@code =>} 小数位数。对于其中的数据类型返回 Null
     * DECIMAL_DIGITS 不适用。
     * <LI><B>NUM_PREC_RADIX</B> int {@code =>} 基数(通常为 10 或 2)
     * <LI><B>NULLABLE</B> int {@code =>} 允许为 NULL。
     * <UL>
     * <LI> columnNoNulls - 可能不允许 <code>NULL</code> 值
     * <LI> columnNullable - 绝对允许 <code>NULL</code> 值
     * <LI> columnNullableUnknown - 可空性未知
     * </UL>
     * <LI><B>REMARKS</B> String {@code =>} 注释描述列(可能是<code>null</code>)
     * <LI><B>COLUMN_DEF</B> String {@code =>} 列的默认值,当值用单引号括起来时应解释为字符串(可能为<code>null</code >)
     * <LI><B>SQL_DATA_TYPE</B> int {@code =>} 未使用
     * <LI><B>SQL_DATETIME_SUB</B> int {@code =>} 未使用
     * <LI><B>CHAR_OCTET_LENGTH</B> int {@code =>} 用于 char 类型
     * 列中的最大字节数
     * <LI><B>ORDINAL_POSITION</B> int {@code =>} 表中列的索引
     *(从 1 开始)
     * <LI><B>IS_NULLABLE</B> String {@code =>} ISO 规则用于确定列的可空性。
     * <UL>
     * <LI> YES --- 如果列可以包含 NULL
     * <LI> NO --- 如果列不能包含 NULL
     * <LI> 空字符串 --- 如果
     * 列未知
     * </UL>
     * <LI><B>SCOPE_CATALOG</B> String {@code =>} 范围表的目录
     * 引用属性(如果 DATA_TYPE 不是 REF,则为 <code>null</code>)
     * <LI><B>SCOPE_SCHEMA</B> String {@code =>} 范围表的模式
     * 引用属性(如果 DATA_TYPE 不是 REF,则为 <code>null</code>)
     * <LI><B>SCOPE_TABLE</B> String {@code =>} 这个范围的表名
     * 引用属性(如果 DATA_TYPE 不是 REF,则为 <code>null</code>)
     * <LI><B>SOURCE_DATA_TYPE</B> 短 {@code =>} 不同类型或用户生成的源类型
     * Ref 类型,来自 java.sql.Types 的 SQL 类型(<code>null</code> if DATA_TYPE
     * 不是 DISTINCT 或用户生成的 REF)
     * <LI><B>IS_AUTOINCREMENT</B> String {@code =>} 表示该列是否自动递增
     * <UL>
     * <LI> YES --- 如果列是自动递增的
     * <LI> NO --- 如果列不是自动递增的
     * <LI> 空字符串 --- 如果无法确定列是否自动递增
     * </UL>
     * <LI><B>IS_GENERATEDCOLUMN</B> String {@code =>} 表示这是否是生成列
     * <UL>
     * <LI> YES --- 如果这是一个生成的列
     * <LI> NO --- 如果这不是生成的列
     * <LI> 空字符串 --- 如果无法确定这是否是生成的列
     * </UL>
     * </OL>
     *
     * <p>COLUMN_SIZE 列指定给定列的列大小。
     * 对于数值数据,这是最大精度。对于字符数据,这是字符长度。
     * 对于日期时间数据类型,这是字符串表示的字符长度(假设
     * 小数秒组件的最大允许精度)。对于二进制数据,这是以字节为单位的长度。对于 ROWID 数据类型,
     * 这是以字节为单位的长度。对于其中的数据类型返回 Null
     * 列大小不适用。
     * @param catalog 一个目录名; 必须与目录名称匹配
      * 存储在数据库中; "" 检索那些没有目录的;
      * <code>null</code> 表示不应该使用目录名称来缩小搜索
      * @param schemaPattern 模式名称模式; 
      * 必须与架构名称匹配因为它存储在数据库中; 
      * "" 检索那些没有模式的;
      * <code>null</code> 表示不应该使用模式名称来缩小范围搜索
      * @param tableNamePattern 一个表名模式; 必须匹配
      * 存储在数据库中的表名
      * @param columnNamePattern 列名模式; 必须与列匹配
      * 名称,因为它存储在数据库中
      * @return <code>ResultSet</code> - 每行是一个列描述
      * @exception SQLException 如果发生数据库访问错误
      * @see #getSearchStringEscape
      */

参数

? String catalog: mysql下就是数据库名称,oracle下就是instance名;可以为null,可以为“”。解释参见@param catalog

? String schemaPattern:mysql下就是数据库名称,oracle中就是用户名.解释参见@param schemaPattern

? String tableNamePattern: 数据表名称

? String columnNamePattern: 列名模式,参考注解中的解释

getPrimaryKeys

getIndexInfo

oracle 和mysql 的 catalog,schema

oracle

Oracle:
server instance == database == catalog: all data managed by same execution engine
schema: namespace within database, identical to user account
user == schema owner == named account: identical to schema, who can connect to database, who owns the schema and use objects possibly in other schemas
to identify any object in running server, you need (schema name + object name)

mysql

MySQL:
server instance == not identified with catalog, just a set of databases
database == schema == catalog: a namespace within the server.
user == named account: who can connect to server and use (but can not own - no concept of ownership) objects in one or more databases
to identify any object in running server, you need (database name)
  开发工具 最新文章
Postman接口测试之Mock快速入门
ASCII码空格替换查表_最全ASCII码对照表0-2
如何使用 ssh 建立 socks 代理
Typora配合PicGo阿里云图床配置
SoapUI、Jmeter、Postman三种接口测试工具的
github用相对路径显示图片_GitHub 中 readm
Windows编译g2o及其g2o viewer
解决jupyter notebook无法连接/ jupyter连接
Git恢复到之前版本
VScode常用快捷键
上一篇文章      下一篇文章      查看所有文章
加:2022-04-29 12:19:58  更:2022-04-29 12:20:29 
 
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁

360图书馆 购物 三丰科技 阅读网 日历 万年历 2024年11日历 -2024/11/14 15:13:44-

图片自动播放器
↓图片自动播放器↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  IT数码