使用JDBC获取各数据库的Meta信息——表以及对应的列

2023-11-19


先贴代码,作为草稿:

第一个是工具类, MapUtil.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * map转换工具
 */
public class MapUtil {
	
	/**
	 * 将List中的Key转换为小写
	 * @param list 返回新对象
	 * @return
	 */
	public static List<Map<String, Object>> convertKeyList2LowerCase(List<Map<String, Object>> list){
		if(null==list) {
			return null;
		}
		List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();
		//
		Iterator<Map<String, Object>> iteratorL = list.iterator();
		while (iteratorL.hasNext()) {
			Map<String, Object> map = (Map<String, Object>) iteratorL.next();
			//
			Map<String, Object> result = convertKey2LowerCase(map);
			if(null != result){
				resultList.add(result);
			}
		}
		//
		return resultList;
	}
	/**
	 * 转换单个map,将key转换为小写. 
	 * @param map 返回新对象
	 * @return
	 */
	public static Map<String, Object> convertKey2LowerCase(Map<String, Object> map){
		if(null==map) {
			return null;
		}
		Map<String, Object> result = new HashMap<String, Object>();
		//
		Set<String> keys  = map.keySet();
		//
		Iterator<String> iteratorK = keys.iterator();
		while (iteratorK.hasNext()) {
			String key = (String) iteratorK.next();
			Object value = map.get(key);
			if(null == key){
				continue;
			}
			//
			String keyL = key.toLowerCase();
			result.put(keyL, value);
		}
		return result;
	}
	/**
	 * 将List中Map的Key转换为小写.
	 * @param list
	 * @return
	 */
	public static List<Map<String, Object>> trimListKeyValue(List<Map<String, Object>> list){
		if(null==list) {
			return null;
		}
		List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();
		//
		Iterator<Map<String, Object>> iteratorL = list.iterator();
		while (iteratorL.hasNext()) {
			Map<String, Object> map = (Map<String, Object>) iteratorL.next();
			//
			Map<String, Object> result = trimKeyValue(map);
			if(null != result){
				resultList.add(result);
			}
		}
		//
		return resultList;
	}
	/**
	 * 转换单个map,将key转换为小写. 
	 * @param map 返回新对象
	 * @return
	 */
	public static Map<String, Object> trimKeyValue(Map<String, Object> map){
		if(null==map) {
			return null;
		}
		Map<String, Object> result = new HashMap<String, Object>();
		//
		Set<String> keys  = map.keySet();
		//
		Iterator<String> iteratorK = keys.iterator();
		while (iteratorK.hasNext()) {
			String key = (String) iteratorK.next();
			Object value = map.get(key);
			if(null == key){
				continue;
			}
			//
			String keyT = key.trim();
			if(value instanceof String){
				String valueT = String.valueOf(value).trim();
				result.put(keyT, valueT);
			} else {
				result.put(keyT, value);
			}
		}
		return result;
	}
}


然后是具体的实现工具类,使用了阿里巴巴的 fastjson 工具包;里面的测试类可以忽略

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.alibaba.fastjson.JSONArray;

/**
 * 需要注意,想要有表字段描述信息,获取连接时需要指定某些特殊属性<br/> 
 * 数据交换-工具类
 */
public class DBMSMetaUtil {


	/**
	 * 数据库类型,枚举
	 * 
	 */
	public static enum DATABASETYPE {
		ORACLE, MYSQL, SQLSERVER, SQLSERVER2005, DB2, INFORMIX, SYBASE, OTHER, EMPTY
	}

	/**
	 * 根据字符串,判断数据库类型
	 * 
	 * @param databasetype
	 * @return
	 */
	public static DATABASETYPE parseDATABASETYPE(String databasetype) {
		// 空类型
		if (null == databasetype || databasetype.trim().length() < 1) {
			return DATABASETYPE.EMPTY;
		}
		// 截断首尾空格,转换为大写
		databasetype = databasetype.trim().toUpperCase();
		// Oracle数据库
		if (databasetype.contains("ORACLE")) {
			//
			return DATABASETYPE.ORACLE;
		}
		// MYSQL 数据库
		if (databasetype.contains("MYSQL")) {
			//
			return DATABASETYPE.MYSQL;
		}
		// SQL SERVER 数据库
		if (databasetype.contains("SQL") && databasetype.contains("SERVER")) {
			//
			if (databasetype.contains("2005") || databasetype.contains("2008") || databasetype.contains("2012")) {

        		try {
					Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				}
				
				return DATABASETYPE.SQLSERVER2005;
			} else {
				try {
					// 注册 JTDS
					Class.forName("net.sourceforge.jtds.jdbc.Driver");
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				}
				return DATABASETYPE.SQLSERVER;
			}
		}
		// 下面的这几个没有经过实践测试, 判断可能不准确
		// DB2 数据库
		if (databasetype.contains("DB2")) {
			//
			return DATABASETYPE.DB2;
		}
		// INFORMIX 数据库
		if (databasetype.contains("INFORMIX")) {
			//
			return DATABASETYPE.INFORMIX;
		}
		// SYBASE 数据库
		if (databasetype.contains("SYBASE")) {
			//
			return DATABASETYPE.SYBASE;
		}

		// 默认,返回其他
		return DATABASETYPE.OTHER;
	}

	/**
	 * 列出数据库的所有表
	 */
	// 可以参考: http://www.cnblogs.com/chinafine/articles/1847205.html
	public static List<Map<String, Object>> listTables(String databasetype, String ip, String port, String dbname,
			String username, String password) {
		// 去除首尾空格
		databasetype = trim(databasetype);
		ip = trim(ip);
		port = trim(port);
		dbname = trim(dbname);
		username = trim(username);
		password = trim(password);
		//
		DATABASETYPE dbtype = parseDATABASETYPE(databasetype);
		//
		List<Map<String, Object>> result = null;
		String url = concatDBURL(dbtype, ip, port, dbname);
		Connection conn = getConnection(url, username, password);
		// Statement stmt = null;
		ResultSet rs = null;
		//
		try {
			// 这句话我也不懂是什么意思... 好像没什么用
			conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
			// 获取Meta信息对象
			DatabaseMetaData meta = conn.getMetaData();
			// 数据库
			String catalog = null;
			// 数据库的用户
			String schemaPattern = null;// meta.getUserName();
			// 表名
			String tableNamePattern = null;//
			// types指的是table、view
			String[] types = { "TABLE" };
			// Oracle
			if (DATABASETYPE.ORACLE.equals(dbtype)) {
				schemaPattern = username;
				if (null != schemaPattern) {
					schemaPattern = schemaPattern.toUpperCase();
				}
				// 查询
				rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);
			} else if (DATABASETYPE.MYSQL.equals(dbtype)) {
				// Mysql查询
				// MySQL 的 table 这一级别查询不到备注信息
				schemaPattern = dbname;
				rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);
			}  else if (DATABASETYPE.SQLSERVER.equals(dbtype) || DATABASETYPE.SQLSERVER2005.equals(dbtype)) {
				// SqlServer
				tableNamePattern = "%";
				rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);
			}  else if (DATABASETYPE.DB2.equals(dbtype)) {
				// DB2查询
				schemaPattern = "jence_user";
				tableNamePattern = "%";
				rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);
			} else if (DATABASETYPE.INFORMIX.equals(dbtype)) {
				// SqlServer
				tableNamePattern = "%";
				rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);
			} else if (DATABASETYPE.SYBASE.equals(dbtype)) {
				// SqlServer
				tableNamePattern = "%";
				rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);
			}  else {
				throw new RuntimeException("不认识的数据库类型!");
			}
			//
			result = parseResultSetToMapList(rs);

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			close(rs);
			close(conn);
		}
		//
		return result;
	}

	/**
	 * 列出表的所有字段
	 */
	public static List<Map<String, Object>> listColumns(String databasetype, String ip, String port, String dbname,
			String username, String password, String tableName) {
		// 去除首尾空格
		databasetype = trim(databasetype);
		ip = trim(ip);
		port = trim(port);
		dbname = trim(dbname);
		username = trim(username);
		password = trim(password);
		tableName = trim(tableName);
		//
		DATABASETYPE dbtype = parseDATABASETYPE(databasetype);
		//
		List<Map<String, Object>> result = null;
		String url = concatDBURL(dbtype, ip, port, dbname);
		Connection conn = getConnection(url, username, password);
		// Statement stmt = null;
		ResultSet rs = null;
		//
		try {
			// 获取Meta信息对象
			DatabaseMetaData meta = conn.getMetaData();
			// 数据库
			String catalog = null;
			// 数据库的用户
			String schemaPattern = null;// meta.getUserName();
			// 表名
			String tableNamePattern = tableName;//
			// 转换为大写
			if (null != tableNamePattern) {
				tableNamePattern = tableNamePattern.toUpperCase();
			}
			// 
			String columnNamePattern = null;
			// Oracle
			if (DATABASETYPE.ORACLE.equals(dbtype)) {
				// 查询
				schemaPattern = username;
				if (null != schemaPattern) {
					schemaPattern = schemaPattern.toUpperCase();
				}
			} else {
				//
			}

			rs = meta.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern);
			// TODO 获取主键列,但还没使用
			meta.getPrimaryKeys(catalog, schemaPattern, tableNamePattern);
			//
			result = parseResultSetToMapList(rs);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 关闭资源
			close(rs);
			close(conn);
		}
		//
		return result;
	}

	/**
	 * 根据IP,端口,以及数据库名字,拼接Oracle连接字符串
	 * 
	 * @param ip
	 * @param port
	 * @param dbname
	 * @return
	 */
	public static String concatDBURL(DATABASETYPE dbtype, String ip, String port, String dbname) {
		//
		String url = "";
		// Oracle数据库
		if (DATABASETYPE.ORACLE.equals(dbtype)) {
			//
			url += "jdbc:oracle:thin:@";
			url += ip.trim();
			url += ":" + port.trim();
			url += ":" + dbname;
			
			// 如果需要采用 hotbackup
			String url2 = "";
			url2 = url2+"jdbc:oracle:thin:@(DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = "
					+ ip.trim() +")(PORT ="+ port.trim() +")))(CONNECT_DATA = (SERVICE_NAME ="+dbname+
					")(FAILOVER_MODE = (TYPE = SELECT)(METHOD = BASIC)(RETRIES = 180)(DELAY = 5))))";
			//
			// url = url2;
		} else if (DATABASETYPE.MYSQL.equals(dbtype)) {
			//
			url += "jdbc:mysql://";
			url += ip.trim();
			url += ":" + port.trim();
			url += "/" + dbname;
		} else if (DATABASETYPE.SQLSERVER.equals(dbtype)) {
			//
			url += "jdbc:jtds:sqlserver://";
			url += ip.trim();
			url += ":" + port.trim();
			url += "/" + dbname;
			url += ";tds=8.0;lastupdatecount=true";
		} else if (DATABASETYPE.SQLSERVER2005.equals(dbtype)) {
			//
			url += "jdbc:sqlserver://";
			url += ip.trim();
			url += ":" + port.trim();
			url += "; DatabaseName=" + dbname;
		} else if (DATABASETYPE.DB2.equals(dbtype)) {
			url += "jdbc:db2://";
			url += ip.trim();
			url += ":" + port.trim();
			url += "/" + dbname;
		} else if (DATABASETYPE.INFORMIX.equals(dbtype)) {
			// Infox mix 可能有BUG
			url += "jdbc:informix-sqli://";
			url += ip.trim();
			url += ":" + port.trim();
			url += "/" + dbname;
			// +":INFORMIXSERVER=myserver;user="+bean.getDatabaseuser()+";password="+bean.getDatabasepassword()
		} else if (DATABASETYPE.SYBASE.equals(dbtype)) {
			url += "jdbc:sybase:Tds:";
			url += ip.trim();
			url += ":" + port.trim();
			url += "/" + dbname;
		} else {
			throw new RuntimeException("不认识的数据库类型!");
		}
		//
		return url;
	}

	/**
	 * 获取JDBC连接
	 * 
	 * @param url
	 * @param username
	 * @param password
	 * @return
	 */
	public static Connection getConnection(String url, String username, String password) {
		Connection conn = null;
		try {
			// 不需要加载Driver. Servlet 2.4规范开始容器会自动载入
			// conn = DriverManager.getConnection(url, username, password);
			//
			Properties info =new Properties();
			//
			info.put("user", username);
			info.put("password", password);
			// !!! Oracle 如果想要获取元数据 REMARKS 信息,需要加此参数
			info.put("remarksReporting","true");
			// !!! MySQL 标志位, 获取TABLE元数据 REMARKS 信息
			info.put("useInformationSchema","true");
			// 不知道SQLServer需不需要设置...
			//
			conn = DriverManager.getConnection(url, info);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 将一个未处理的ResultSet解析为Map列表.
	 * 
	 * @param rs
	 * @return
	 */
	public static List<Map<String, Object>> parseResultSetToMapList(ResultSet rs) {
		//
		List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
		//
		if (null == rs) {
			return null;
		}
		//
		try {
			while (rs.next()) {
				// 
				Map<String, Object> map = parseResultSetToMap(rs);
				//
				if (null != map) {
					result.add(map);
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		//
		return result;
	}

	/**
	 * 解析ResultSet的单条记录,不进行 ResultSet 的next移动处理
	 * 
	 * @param rs
	 * @return
	 */
	private static Map<String, Object> parseResultSetToMap(ResultSet rs) {
		//
		if (null == rs) {
			return null;
		}
		//
		Map<String, Object> map = new HashMap<String, Object>();
		//
		try {
			ResultSetMetaData meta = rs.getMetaData();
			//
			int colNum = meta.getColumnCount();
			//
			for (int i = 1; i <= colNum; i++) {
				// 列名
				String name = meta.getColumnLabel(i); // i+1
				Object value = rs.getObject(i);
				// 加入属性
				map.put(name, value);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		//
		return map;
	}
	
	//
	public static boolean TryLink(String databasetype, String ip, String port, String dbname, String username, String password) {
		//
		DATABASETYPE dbtype = parseDATABASETYPE(databasetype);
		String url = concatDBURL(dbtype, ip, port, dbname);
		Connection conn = null;
		//
		try {
			conn = getConnection(url, username, password);
			if(null == conn){
				return false;
			}
			DatabaseMetaData meta =  conn.getMetaData();
			//
			if(null == meta){
				return false;
			} else {
				// 只有这里返回true
				return true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			close(conn);
		}
		//
		return false;
	}
	//
	public static void close(Connection conn) {
		if(conn!=null) {
			try {
				conn.close();
				conn = null;
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	//
	public static void close(Statement stmt) {
		if(stmt!=null) {
			try {
				stmt.close();
				stmt = null;
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	//
	public static void close(ResultSet rs) {
		if(rs!=null) {
			try {
				rs.close();
				rs = null;
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	//
	public static String trim(String str){
		if(null != str){
			str = str.trim();
		}
		return str;
	}

	public static void main(String[] args) {
		//testLinkOracle();
		//testLinkSQLServer();
		testOracle();
		//testMySQL();
	}

	//
	public static void testLinkOracle() {
		//
		String ip= "192.168.0.100";
		String port= "1521"; 
		String dbname= "orcl"; 
		String username= "username"; 
		String password= "*****pwd";
		String databasetype= "oracle";
		//
		String url = concatDBURL(parseDATABASETYPE(databasetype), ip, port, dbname);
		System.out.println("url="+url);
		//
		boolean result = TryLink(databasetype, ip, port, dbname, username, password);
		//
		System.out.println("result="+result);
	}

	//
	public static void testLinkSQLServer() {
		//
		String ip= "192.168.0.100";
		String port= "1433"; 
		String dbname= "sqlserverdb1"; 
		String username= "sa"; 
		String password= "186957";
		String databasetype= "SQL Server";
		//
		String url = concatDBURL(parseDATABASETYPE(databasetype), ip, port, dbname);
		System.out.println("url="+url);
		//
		boolean result = TryLink(databasetype, ip, port, dbname, username, password);
		//
		System.out.println("result="+result);
	}
	
	
	
	public static void testOracle() {
		//
		String ip = "192.168.0.100";
		String port = "1521";
		String dbname = "orcl";
		String username = "unixsys";
		String password = "orpass";
		//
		String databasetype = "Oracle";
		// DATABASETYPE dbtype = parseDATABASETYPE(databasetype);
		// System.out.println(DATABASETYPE.ORACLE.equals(dbtype));
		//
		String tableName = "DBMS_CODE_CHEME_NEW";

		List<Map<String, Object>> tables = listTables(databasetype, ip, port, dbname, username, password);
		List<Map<String, Object>> columns = listColumns(databasetype, ip, port, dbname, username, password, tableName);
		//
		tables = MapUtil.convertKeyList2LowerCase(tables);
		columns = MapUtil.convertKeyList2LowerCase(columns);
		//
		String jsonT = JSONArray.toJSONString(tables, true);
		System.out.println(jsonT);
		System.out.println("tables.size()=" + tables.size());
		//
		System.out.println("-----------------------------------------" + "-----------------------------------------");
		System.out.println("-----------------------------------------" + "-----------------------------------------");
		//
		String jsonC = JSONArray.toJSONString(columns, true);
		System.out.println(jsonC);
		System.out.println("columns.size()=" + columns.size());
	}
	

	public static void testMySQL() {
		//
		String ip = "127.0.0.1";
		String port = "4050";
		String 
			dbname = "cncounter";
			dbname = "eReqDlG";
		String 
			username = "root";
			username = "6EhSiGpsmSMRr";
		String 
			password = "eoNRNBgRk397mVy";
		//
		String databasetype = "mysql";
		// DATABASETYPE dbtype = parseDATABASETYPE(databasetype);
		// System.out.println(DATABASETYPE.ORACLE.equals(dbtype));
		//
		String tableName = "vote";

		List<Map<String, Object>> tables = listTables(databasetype, ip, port, dbname, username, password);
		List<Map<String, Object>> columns = listColumns(databasetype, ip, port, dbname, username, password, tableName);
		//
		tables = MapUtil.convertKeyList2LowerCase(tables);
		columns = MapUtil.convertKeyList2LowerCase(columns);
		//
		String jsonT = JSONArray.toJSONString(tables, true);
		System.out.println(jsonT);
		System.out.println("tables.size()=" + tables.size());
		//
		System.out.println("-----------------------------------------" + "-----------------------------------------");
		System.out.println("-----------------------------------------" + "-----------------------------------------");
		//
		String jsonC = JSONArray.toJSONString(columns, true);
		System.out.println(jsonC);
		System.out.println("columns.size()=" + columns.size());
	}
	// 演示 DatabaseMetaData
	public static void demoDatabaseMetaData() {
		try {
			Class.forName("com.mysql.jdbc.Driver");
			Connection con = DriverManager.getConnection("jdbc:mysql://localhost/dbtest", "root", "root");
			//
			DatabaseMetaData dmd = con.getMetaData();
			System.out.println("当前数据库是:" + dmd.getDatabaseProductName());
			System.out.println("当前数据库版本:" + dmd.getDatabaseProductVersion());
			System.out.println("当前数据库驱动:" + dmd.getDriverVersion());
			System.out.println("当前数据库URL:" + dmd.getURL());
			System.out.println("当前数据库是否是只读模式?:" + dmd.isReadOnly());
			System.out.println("当前数据库是否支持批量更新?:" + dmd.supportsBatchUpdates());
			System.out.println("当前数据库是否支持结果集的双向移动(数据库数据变动不在ResultSet体现)?:"
					+ dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
			System.out.println("当前数据库是否支持结果集的双向移动(数据库数据变动会影响到ResultSet的内容)?:"
					+ dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
			System.out.println("========================================");

			ResultSet rs = dmd.getTables(null, null, "%", null);
			System.out.println("表名" + "," + "表类型");
			while (rs.next()) {
				System.out.println(rs.getString("TABLE_NAME") + "," + rs.getString("TABLE_TYPE"));
			}
			System.out.println("========================================");

			rs = dmd.getPrimaryKeys(null, null, "t_student");
			while (rs.next()) {
				System.out.println(rs.getString(3) + "表的主键是:" + rs.getString(4));
			}
			System.out.println("========================================");

			rs = dmd.getColumns(null, null, "t_student", "%");
			System.out.println("t_student表包含的字段:");
			while (rs.next()) {
				System.out.println(rs.getString(4) + " " + rs.getString(6) + "(" + rs.getString(7) + ");");
			}
			System.out.println("========================================");

		} catch (Exception e) {
			System.out.println("数据库操作出现异常");
		}
	}

	// ResultSetMetaData 使用示例
	// 此方法参考 http://blog.csdn.net/yirentianran/article/details/2950321
	public static void demoResultSetMetaData(ResultSetMetaData data) throws SQLException {
		for (int i = 1; i <= data.getColumnCount(); i++) {
			// 获得所有列的数目及实际列数
			int columnCount = data.getColumnCount();
			// 获得指定列的列名
			String columnName = data.getColumnName(i);
			// 获得指定列的列值
			// String columnValue = rs.getString(i);
			// 获得指定列的数据类型
			int columnType = data.getColumnType(i);
			// 获得指定列的数据类型名
			String columnTypeName = data.getColumnTypeName(i);
			// 所在的Catalog名字
			String catalogName = data.getCatalogName(i);
			// 对应数据类型的类
			String columnClassName = data.getColumnClassName(i);
			// 在数据库中类型的最大字符个数
			int columnDisplaySize = data.getColumnDisplaySize(i);
			// 默认的列的标题
			String columnLabel = data.getColumnLabel(i);
			// 获得列的模式
			String schemaName = data.getSchemaName(i);
			// 某列类型的精确度(类型的长度)
			int precision = data.getPrecision(i);
			// 小数点后的位数
			int scale = data.getScale(i);
			// 获取某列对应的表名
			String tableName = data.getTableName(i);
			// 是否自动递增
			boolean isAutoInctement = data.isAutoIncrement(i);
			// 在数据库中是否为货币型
			boolean isCurrency = data.isCurrency(i);
			// 是否为空
			int isNullable = data.isNullable(i);
			// 是否为只读
			boolean isReadOnly = data.isReadOnly(i);
			// 能否出现在where中
			boolean isSearchable = data.isSearchable(i);
			System.out.println(columnCount);
			System.out.println("获得列" + i + "的字段名称:" + columnName);
			// System.out.println("获得列" + i + "的字段值:" + columnValue);
			System.out.println("获得列" + i + "的类型,返回SqlType中的编号:" + columnType);
			System.out.println("获得列" + i + "的数据类型名:" + columnTypeName);
			System.out.println("获得列" + i + "所在的Catalog名字:" + catalogName);
			System.out.println("获得列" + i + "对应数据类型的类:" + columnClassName);
			System.out.println("获得列" + i + "在数据库中类型的最大字符个数:" + columnDisplaySize);
			System.out.println("获得列" + i + "的默认的列的标题:" + columnLabel);
			System.out.println("获得列" + i + "的模式:" + schemaName);
			System.out.println("获得列" + i + "类型的精确度(类型的长度):" + precision);
			System.out.println("获得列" + i + "小数点后的位数:" + scale);
			System.out.println("获得列" + i + "对应的表名:" + tableName);
			System.out.println("获得列" + i + "是否自动递增:" + isAutoInctement);
			System.out.println("获得列" + i + "在数据库中是否为货币型:" + isCurrency);
			System.out.println("获得列" + i + "是否为空:" + isNullable);
			System.out.println("获得列" + i + "是否为只读:" + isReadOnly);
			System.out.println("获得列" + i + "能否出现在where中:" + isSearchable);
		}
	}

}


需要整理后才能发布.


本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

使用JDBC获取各数据库的Meta信息——表以及对应的列 的相关文章

  • MariaDB 未启动:“插件‘反馈’已禁用。”

    我在 CentOS 7 上安装了 MariaDB 10 2 10 但它停止运行 如果我做 If I do systemctl restart mariadb service I get mariadb service main proces
  • 使用 H2 数据库在 JDBC 中将年份从负 -509 更改为正 510

    509 vs 510 我在使用 JDBC 时看到某种已更改或错误的数据 所以我观察使用H2数据库 http h2database com Java 8 更新 151 上的版本 1 4 196 这是一个完整的例子 请注意我们如何检索日期值三次
  • Java 8 升级后无法获取数据库连接

    我最近将一个应用程序从 java 1 7 升级到 1 8 其余库版本保持不变 升级后我收到以下错误 DEBUG 2015 11 12 09 55 12 BasicResourcePool An exception occurred whil
  • 网络适​​配器无法建立连接 - Oracle 11g

    我编写了一个 servlet 程序 我希望它连接到我的 Oracle 数据库 但它给了我一个错误 我正在使用 Eclipse Helios Tomcat 6 0 37 Oracle 11g 11 2 0 1 0 ojdbc6 jar 在服
  • 停止或终止 JDBC 中长时间运行的查询

    有什么方法可以停止或终止 JDBC 中长时间运行的 Oracle 查询吗 通常最终会重新启动应用程序服务器以使 jdbc 与 Oracle DB 断开连接 寻找类似于 SQL Plus 的功能 Kill session在 Java 或 JD
  • 如何在flyway创建的postgresql jdbc连接上设置时区?

    我有一个 postgresql 数据库 我使用 Flyway 将脚本部署到该数据库 我使用 Maven Flyway 插件启动针对目标数据库的数据库构建 在该构建中 我有一些脚本可以执行以下操作 create table my table
  • WAMP服务器将MySQL切换为MariaDB

    如何在WAMP 3 1 0中将数据库从MySQL切换到MariaDB 我正在寻找它 但我找不到它 从您显示的图像来看 MySQL 和 MariaDB 似乎都已经在运行 注意 这有点占用内存 简单测试看看 MySQL 和 MariaDB 是否
  • 挂载卷时无法运行 mariadb

    使用以下 docker compose yml 文件 version 2 services wordpress image wordpress ports 8080 80 environment WORDPRESS DB NAME my d
  • JDBC多线程插入可以吗?

    我目前正在开发一个 Java 项目 我需要准备一个大的 对我来说 mysql 数据库 我必须使用 Jsoup 进行网页抓取并将结果存储到我的数据库中 据我估计 我将大约插入 1 500 000 到 2 000 000 条记录 在我的第一次试
  • 从 MySql 迁移:MariaDB 服务器意外关闭客户端连接

    由于许可 商业使用原因 我们正在从 MySql 迁移到 MariaDB 我们已经成功用 MariaDB 客户端 jar 替换了 MySql 连接器 jar 第一次更改 现在正在尝试用 MariaDB 服务器替换 MySql 服务器而不更改数
  • PostgreSQL JDBC4 的连接池

    最近我从以下网站下载了 PostgreSQL 的 JDBC 驱动程序here https jdbc postgresql org download html 由于我使用的是 Java 1 7 JVM 并且它是这样写的 如果您使用 1 6 或
  • getArray 上的 SQLFeatureNotSupportedException

    使用 MySQL 5 5 STS 2 9 2 mysql connector java 5 1 21 bin jar 我想从 ResultSet 中获取一个数组 所以我这样编码 try Connection conn DriverManag
  • 使用java将数据插入mySQL表

    I have a predefined table in a mySQL database 我正在努力将从用户输入的数据保存到数据库中 但我似乎无法将任何数据保存在数据库中 使用以下代码 我尝试更新数据库的第一行 ID 1 到 OTHER
  • 超时后如何重新建立 JDBC 连接?

    我有一个长时间运行的方法 它通过 EntityManager TopLink Essentials 执行大量本机 SQL 查询 每个查询只需要几毫秒即可运行 但查询数量却有数千个 这发生在单个 EJB 事务内 15 分钟后 数据库关闭连接
  • 如何使用 JDBC 将大型(或至少是重要的)BLOB 放入 Oracle 中?

    我正在开发一个应用程序来执行一些批处理 并且希望将输入和输出数据作为文件存储在 Oracle 数据库的 BLOB 字段中 Oracle版本是10g r2 使用如下的PreparedStatement setBinaryStream 方法会将
  • 在 JDBC PL/SQL 块中多次使用命名参数时出错

    当使用命名参数调用 PL SQL 块时出现错误 当所有命名参数仅使用一次时 我的代码工作正常 但是当我复制标有 SQL 的 SQL 时 然后所有命名参数 以冒号开头 q 都使用了两次 现在我得到一个 SQL 异常 它说 参数名称的数量与注册
  • 声纳+MS SQL数据库

    我正在尝试使用 mssql 服务器数据库初始化声纳 但我不能 使用 Microsoft SQL Server Management Studio 我创建了用户名 sonar 和密码 sonar 的用户 并向同时创建的 sonar 数据库授予
  • JDBC中为什么要关闭连接?如果我们不这样做,会发生什么

    在java中与数据库通信 我们经常遵循以下步骤 加载驱动程序 建立连接 创建声明或PreparedStatement get the ResultSet 关闭连接 我很困惑我们应该关闭连接 都说创建连接很昂贵 所以为什么我们不能这样做 st
  • 用Java将图像添加到数据库

    我正在尝试将图像添加到 mysql 数据库中的 BLOB 字段 图像大小将小于 100kb 但是我遇到了问题 想知道将这些数据添加到数据库的更好方法是什么 com mysql jdbc MysqlDataTruncation 数据截断 第
  • H2控制台看不到JAVA创建的表

    我已经从以下位置下载了 H2 控制台http www h2database com html download html http www h2database com html download html我已经在我的中配置了 URLjdb

随机推荐

  • 9月,Java岗爆了!

    你有面试机会了吗 随着金九银十到来 肯定有很多小伙伴想抓住一年两次的机会 开始疯狂投简历了吧 但是事实是 投出去的简历基本上HR都是已读不回 收到面试邀请 被告知不用面试了 参加了面试 就像走了个过场 成了HR的业绩指标 面试通过 但是被放
  • LWIP在STM32上的移植

    本文做记录摘抄 加上自己的体会 文章标题 STM32使用LWIP实现DHCP客户端 http www cnblogs com dengxiaojun p 4379545 html 该文章介绍了几点 LWIP源码的内容 关键点 1 inclu
  • id选择器和class选择器

    id选择器 id选择器用来选取带有给定id属性的元素 语法 id例如 html div div css container color blue id选择器的一些特征 1 id选择器以 号开头 后跟元素的id属性值 2 id选择器只能选取带
  • 英伟达最新开源

    Title FasterViT Fast Vision Transformers with Hierarchical Attention Paper https arxiv org pdf 2306 06189 pdf Code https
  • 《Terraform 101 从入门到实践》 Functions函数

    Terraform 101 从入门到实践 这本小册在南瓜慢说官方网站和GitHub两个地方同步更新 书中的示例代码也是放在GitHub上 方便大家参考查看 Terraform的函数 Terraform为了让大家在表达式上可以更加灵活方便地进
  • 计算从指定日期开始的第几周的周几的日期

    项目场景 拿到的排课表数据 里面没有具体日期 而是第几周 周几的形式 需要转换成具体日期 问题描述 其中的周几是从周一开始的 从1 到7 转换时也是按这个顺序来 原因分析 先需要获取到学期开始的日期 例 date1 得出是周几 例 周3 是
  • Java实现动态数组

    Java中动态数组的实现是非常常见的数据结构 可以用来存储一组数据并动态调整数组的大小 本文将以 Java 语言为例 介绍如何实现一个简单的动态数组 其中包含基本操作如增加 删除 查询和遍历等 1 定义动态数组 在Java中 可以使用int
  • systemc verilog IEEE 注册登录下载

    https accellera org downloads standards systemrdl SystemRDL 2 0 SystemRDL Register Description Language 一次定义 多种HDL语言场合使用
  • 深入了解计算机端口(2)

    转载 url http www exam8 com computer spks ziliao ws 200504 10798 2 html url Virtualizing DNS DHCP Soft appliances for easy
  • Webstorm使用心得

    原文来自 http www jianshu com p 4ce97b360c13 Webstorm 大多数配置都在File gt Settings选项卡中进行的 也许你不得不第一个记住它的快捷键 Ctrl Alt S 1 设置开发工具主题
  • Edraw Max教程】如何有趣的创建梦幻般的思维导图

    Edraw Max 亿图图示 是一款综合图形图表制作软件 它包含丰富的实例和模版 帮助您轻松创建流程图 网络拓扑图 组织结构图 商业图表 工程图 思维导图 软件设计图和平面布局图等 亿图采用更智能和人性化的绘制方式 最大程度帮助设计者降低工
  • 九度OJ 1193:矩阵转置 (矩阵计算)

    时间限制 1 秒 内存限制 32 兆 特殊判题 否 提交 1673 解决 1132 题目描述 输入一个N N的矩阵 将其转置后输出 要求 不得使用任何数组 就地逆置 输入 输入的第一行包括一个整数N 1 lt N lt 100 代表矩阵的维
  • react umi实战

    umi umiJs是一个类Next JS的react开发框架 它基于一个约定 即pages目录下的文件即路由 而文件则导出react组件 然后打通从源码到产物的每个阶段 并配以完善的插件体系 让我们能把umi的产物部署到各个场景里面 初始化
  • Unity发布时出现“The type or namespace name `UnityEditor' could not be found.

    现象 using UnityEditor 就算包含了头文件 也会报错 原因 在非编辑器脚本中加入编辑器脚本时 修改方法 1 在Asset中创建Editor文件夹 并将有对Editor操作的脚本全放入到该文件夹中 再次运行之前出错的函数 问题
  • java中的自定义对象排序

    对于数组排序我们知道有Arrays sort 方法 但是如果遇到想要对一个对象数组中的某个属性进行排序 我们该如何去做呢 以给学生成绩排序为例 首先创建一个存储学生对象的数组 package JAVA API public class So
  • 容器数据持久化

    一 挂载方式 Docker提供三种方式将数据从宿主机挂载到容器中 volumes Docker管理宿主机文件系统的一部分 var lib docker volumes 保存数据的最佳方式 bind mounts 将宿主机上的任意位置的文件或
  • Python爬虫-MongoDB

    Python爬虫 MongoDB 文章目录 Python爬虫 MongoDB 前言 与MySQL对比 启动 关闭MongoDB 操作 数据库操作 集合操作 数据操作 增 删 改 查 保存 运算符 高级操作 聚合 常用管道 常用表达式 安全性
  • QT5中 类成员变量的初始化

    不能 类的声明中 进行 QString usr id admin 这样的初始化 初始化要到在初始化参数列表中
  • [FAQ09104]进入应用界面后发现会闪屏,此时要如何定位是否是relaunch activity引起的闪屏呢

    DESCRIPTION 进入应用界面后发现会闪屏 此时要如何定位是否是relaunch activity引起的闪屏呢 SOLUTION 1 对于这类问题 抓取log时记得要打开AMS的log开关 adb shell dumpsys acti
  • 使用JDBC获取各数据库的Meta信息——表以及对应的列

    先贴代码 作为草稿 第一个是工具类 MapUtil java import java util ArrayList import java util HashMap import java util Iterator import java