精华内容
下载资源
问答
  • java根据excel生成 hive建表语句 可以根据自己的格式修改
  • Java sql语句设计建表

    2013-06-17 14:19:24
    sql语句建表 关键表之间的多表链接 表之间的关系结构,通过订单查询
  • Excel生成MYSQL建表语句

    2020-12-25 17:11:41
    JAVA编写,填写好excel模板,点击“点我运行.bat”,即可生成sql语句。没有积分下载的话可以看我的文章,有完成的源代码。
  • } 具体解析方法, 这里最好从数据库获取建表语句, 因为mysql会给我们格式化一下, 这样获取到的是标准的建表语句. public List getKeyInfo(String tableName) throws Exception { List resList = new ArrayList(); ...

    查阅了多方面资料, 对比以下几种方案

    一.尝试方案一 

    DatabaseMetaData , 这种方式代码如下, 这种方式获取的索引类型其实是

     *  tableIndexStatistic - 此标识与表的索引描述一起返回的表统计信息 
    *   tableIndexClustered - 此为集群索引 
    *   tableIndexHashed - 此为散列索引 
    *   tableIndexOther - 此为某种其他样式的索引 

    因为我也没有具体创建过这几种索引,所以也不认识. 但是很明显不符合我们的需求. 

        /**
         * 获得一个表的索引信息
         * getIndexInfo
         * catalog : 类别名称,因为存储在此数据库中,所以它必须匹配类别名称。该参数为 “” 则检索没有类别的描述,为 null 则表示该类别名称不应用于缩小搜索范围
         * schema : 模式名称,因为存储在此数据库中,所以它必须匹配模式名称。该参数为 “” 则检索那些没有模式的描述,为 null 则表示该模式名称不应用于缩小搜索范围
         * table : 表名称,因为存储在此数据库中,所以它必须匹配表名称
         * unique : 该参数为 true 时,仅返回惟一值的索引;该参数为 false 时,返回所有索引,不管它们是否惟一
         * approximate : 该参数为 true 时,允许结果是接近的数据值或这些数据值以外的值;该参数为 false 时,要求结果是精确结果
         */
        public void queryIndexInfo(String dbName, String tableName, DatabaseMetaData metaData) {
            ResultSet rs = null;
            try {
                rs = metaData.getIndexInfo(null, dbName, tableName, false, true);
                while (rs.next()) {
                    String ascOrDesc = rs.getString("ASC_OR_DESC");         // 列排序顺序: 升序还是降序
                    int cardinality = rs.getInt("CARDINALITY");             // 基数
                    short ordinalPosition = rs.getShort("ORDINAL_POSITION");// 在索引列顺序号
                    boolean nonUnique = rs.getBoolean("NON_UNIQUE");        // 非唯一索引(Can index values be non-unique. false when TYPE is  tableIndexStatistic   )
                    String indexQualifier = rs.getString("INDEX_QUALIFIER");// 索引目录(可能为空)
                    String indexName = rs.getString("INDEX_NAME");          // 索引的名称
                    short indexType = rs.getShort("TYPE");          // 索引类型
                    String columnName = rs.getString("COLUMN_NAME");
                }
            } catch (SQLException e) {
                log.error(e.getMessage(), e);
            } finally {
                // 
            }
        }

    二.方案二

    select
    table_name, column_name, column_key
    from
    information_schema.`COLUMNS`
    where
      table_schema = 'proxy'
      and table_name = 'dim_nor'

    自定义查询语句从 information_schema.`COLUMNS` 中获取索引信息, 但是获取的索只有三种类型

    PRI:  主键约束;

    UNI:  唯一约束;

    MUL: 可以重复。

      很明显也不符合需求

    三.方案三

    show index from dim_pri
    show key from dim_pri

    这种方式也没能达到要求.

    四.方案四

    使用sql解析器来解析建表语句

    这里同学有空的话可以找找有没有成熟的方案, 例如 DRUIDjsqlparser

    这里因为我只需要解析建表语句, 所以我还是自己写了一下. 多余的不说了, 上代码

    定义两个基本对象

    package com.biubiu.dms.core.model;
    
    import lombok.Data;
    
    import java.util.List;
    
    /**
     * @author :张音乐
     * @date :Created in 2021/8/13 下午12:56
     * @description:索引信息
     * @email: zhangyule1993@sina.com
     * @version:
     */
    @Data
    public class QueryKey {
        private String indexName;
        private String indexType;
        private List<IndexColumn> indexColumns;
    }
    package com.biubiu.dms.core.model;
    
    import lombok.Data;
    
    /**
     * @author :张音乐
     * @date :Created in 2021/8/13 下午12:57
     * @description:索引包含列
     * @email: zhangyule1993@sina.com
     * @version:
     */
    @Data
    public class IndexColumn {
        private String columnName;
        private String length;
        private String order;
    }

     具体解析方法, 这里最好从数据库获取建表语句, 因为mysql会给我们格式化一下, 这样获取到的是标准的建表语句.

    
        public List<QueryKey> getKeyInfo(String tableName) throws Exception {
            List<QueryKey> resList = new ArrayList<>();
            String sql = "SHOW CREATE TABLE `" + tableName + "`";
            // 执行查询 ..省略, 毕竟每个人不一样
            // 假设你是用jdbc来查询, 那么这里ResultSet 中获取 "Create Table" 字段.
            String text = rs.getString("Create Table").toString().toLowerCase();
            String temp = org.apache.commons.lang3.StringUtils.substringAfter(text, "(");
            String temp2 = org.apache.commons.lang3.StringUtils.substringBeforeLast(temp, ")");
            String [] arr = org.apache.commons.lang3.StringUtils.split(temp2, "\n");
            List<String> keyTextList = Arrays.stream(arr).filter(p -> p.contains("key") || p.contains("index")).collect(Collectors.toList());
            for(int i = 0; i < keyTextList.size(); i++) {
                QueryKey queryKey = new QueryKey();
                String item = keyTextList.get(i);
                // 获取 索引类型
                String type = getKeyType(item);
                queryKey.setIndexType(type);
                // 获取索引名称
                String indexName = getKeyName(item, type);
                queryKey.setIndexName(indexName);
                // 获取索引字段
                String fieldInfoAfter = org.apache.commons.lang3.StringUtils.substringAfter(item, "(");
                String fieldInfo = org.apache.commons.lang3.StringUtils.substringBeforeLast(fieldInfoAfter, ")");
                String[] columns = org.apache.commons.lang3.StringUtils.split(fieldInfo, ",");
                List<IndexColumn> columnsList = getKeyColumns(columns);
                queryKey.setIndexColumns(columnsList);
                resList.add(queryKey);
            }
            return resList;
        }
    
        private List<IndexColumn> getKeyColumns(String[] columns) {
            List<IndexColumn> columnsList = Arrays.stream(columns).map(p -> {
                // `id`
                // `name`(2) DESC
                IndexColumn indexColumn = new IndexColumn();
                String columnName = org.apache.commons.lang3.StringUtils.substringBetween(p, "`", "`");
                indexColumn.setColumnName(columnName);
                String regEx="[^0-9]";
                Pattern pattern = Pattern.compile(regEx);
                Matcher m = pattern.matcher(p);
                // 前缀限制长度
                String length = m.replaceAll("").trim();
                indexColumn.setLength(length);
                String order = p.contains("desc") ? "DESC" : "ASC";
                indexColumn.setOrder(order);
                return indexColumn;
            }).collect(Collectors.toList());
            return columnsList;
        }
    
        private String getKeyName(String item, String type) {
            String indexName = "";
            if(type.equals("Primary")) {
                // 主键索引一定是 PRIMARY, 但是在建表语句中是省略的
                indexName = "PRIMARY";
            } else {
                String itemAfter = org.apache.commons.lang3.StringUtils.substringAfter(item, "key");
                indexName = org.apache.commons.lang3.StringUtils.substringBefore(itemAfter, "(").replaceAll("`", "").trim();
            }
            return indexName;
        }
    
        private String getKeyType(String item) {
            String type = "Normal";
            String keyType = org.apache.commons.lang3.StringUtils.substringBefore(item, "key");
            if(org.apache.commons.lang3.StringUtils.isNotBlank(keyType)) {
                if(keyType.trim().equals("primary") ) {
                    type = "Primary";
                }
                if(keyType.trim().equals("unique")) {
                    type = "Unique";
                }
                if(keyType.trim().equals("fullText")) {
                    type = "FullText";
                }
                if(keyType.trim().equals("spatial")) {
                    type = "Spatial";
                }
            }
            return type;
        }
    

    格式如下:

    [
        // 例如 Primary Key `id`
        {
            "indexName":"PRIMARY",
            "indexType":"Primary",
            "indexColumns":[
                {
                    "columnName":"id",
                    "length":"",
                    "order":"ASC"
                }
            ]
        },
        // 例如 Unique Key (`id`, `name`(2) DESC )
        {
            "indexName":"idx_ss",
            "indexType":"Unique",
            "indexColumns":[
                {
                    "columnName":"id",
                    "length":"",
                    "order":"ASC"
                },
                {
                    "columnName":"name",
                    "length":"2",
                    "order":"DESC"
                }
            ]
        }
    ]

    用这种方式的化在建表的时候就需要规范以下建表规则了, 但是应该可以覆盖大部分了.

    展开全文
  • SpringBoot运行建表语句

    千次阅读 2019-05-28 09:17:54
    运行建表语句 默认将文件命名为:schema‐*.sql、data‐*.sql。 默认使用schema.sql,schema‐all.sql。 如果要自定义的话,可以在配置文件中加入: spring: datasource: username: xxxx password:...

    导入JDBC

    其实都已经在创建springboot的时候导入了。

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring‐boot‐starter‐jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql‐connector‐java</artifactId>
        <scope>runtime</scope>
    </dependency>

    编写配置文件

    spring:
        datasource:
            username: xxxx
            password: xxx
            url: jdbc:mysql://xxxx:3306/xxxx
            driver‐class‐name: com.mysql.cj.jdbc.Driver

    运行建表语句

    默认将文件命名为:schema‐*.sql、data‐*.sql。

    默认使用schema.sql,schema‐all.sql。

    如果要自定义的话,可以在配置文件中加入:

    spring:
        datasource:
            username: xxxx
            password: xxx
            url: jdbc:mysql://xxxx:3306/xxxx
            driver‐class‐name: com.mysql.cj.jdbc.Driver
            schema:
                ‐ classpath:department.sql //自己制定存放目录和文件名

    参考文件

    尚硅谷-Spring Boot核心技术-笔记

    展开全文
  • oracle向mysql建表语句的迁移。 直接表结构的生成sql脚本
  • clickhouse建表语句

    2021-04-14 10:12:02
    import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class Demo { public static void main(String[] ...
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class Demo {
    	public static void main(String[] args) {
    		Connection connection = null;
    		try {
    			Class.forName("com.github.housepower.jdbc.ClickHouseDriver");
    			connection = DriverManager.getConnection("jdbc:clickhouse://localhost:9000");
    
    			System.out.println("连接成功");
    			Statement statement = connection.createStatement();
    			ResultSet executeQuery = statement.executeQuery("create table info(id String,name String, phone String, location String) Engine=ReplacingMergeTree primary key id order by id");		
    
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}finally {
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    
    	}
    
    }
    
    
    展开全文
  • // 返回建表语句语句,查询结果的第二列是建表语句,第一列是表名 return rs.getString(2); } } catch (Exception e) { e.printStackTrace(); try { if (null != pstmt) { pstmt....

    使用 mysqldump 备份数据库也是可行的,因为每次备份的时候都需要mysqldump这个文件, 我在windows备份时没问题,但是放到linux上面时,centos系统死活不认这个文件,但又不想装mysql,一气之下自己研究了个不需要mysqldump就可以备份的程序,

    如果看了以下代码还有不懂的地方,这个网站有我的联系方式http://www.huashuku.top/about.htm, 站长就是我本人

    废话不多说,直接上代码

    添加jdbc驱动 和httpClient的 maven依赖

    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
    	<artifactId>httpclient</artifactId>
    	<version>4.1.2</version>
    </dependency>
    <dependency>
    	<groupId>org.apache.httpcomponents</groupId>
    	<artifactId>httpclient-cache</artifactId>
    	<version>4.1.2</version>
    </dependency>
    <dependency>
    	<groupId>org.apache.httpcomponents</groupId>
    	<artifactId>httpmime</artifactId>
    	<version>4.1.2</version>
    </dependency>
    
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<version>5.1.15</version>
    	<scope>runtime</scope>
    </dependency>

    备份程序

    package com.mysql.bak;
    
    import java.math.BigDecimal;
    import java.sql.Connection;
    import java.sql.DatabaseMetaData;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.List;
    
    import com.utils.FileUtils;
    
    /**
     * 利用jdbc备份mysql数据库--不用mysqldump
     *
     */
    public class BakDateBase {
    
    	private String DRIVER = "com.mysql.jdbc.Driver";
    	private String URL = null; // "jdbc:mysql://182.xxx.xxx.xxx:3306/xd_love_dev?useUnicode=true&characterEncoding=utf8";
    	private String USERNAME = null;// "root";
    	private String PASSWORD = null;//"woaini";
    
    	// 备份的文件地址
    	private String filePath;
    
    	private Connection conn = null;
    
    	private String SQL = "SELECT * FROM ";// 数据库操作
    
    	/**
    	 * 
    	 * <构造函数>
    	 * 
    	 * @param ip
    	 *            数据库ip地址
    	 * @param database
    	 *            数据库名称
    	 * @param userName
    	 *            数据库用户名
    	 * @param password
    	 *            密码
    	 * @param bakFilePath
    	 *            备份的地址
    	 */
    	public BakDateBase(String ip, String database, String userName, String password, String bakFilePath) {
    		try {
    			Class.forName(this.DRIVER);
    			this.URL = String.format("jdbc:mysql://%s:3306/%s?useUnicode=true&characterEncoding=utf8", ip, database);
    
    			this.USERNAME = userName;
    			this.PASSWORD = password;
    			
    			SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-ddHH时mm分ss秒");
    			String datetime = tempDate.format(new java.util.Date());
    			//自动加上时间戳
    			datetime = datetime + "_数据库名称:" + database ;
    			if(bakFilePath.indexOf(".") != -1) {
    				bakFilePath = bakFilePath.replace(".", datetime+".");
    			} else {
    				bakFilePath = datetime + ".sql";
    			}
    			this.filePath = bakFilePath;
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    			System.err.println("can not load jdbc driver");
    		}
    	}
    
    	/**
    	 * 获取数据库连接
    	 *
    	 * @return
    	 */
    	private Connection getConnection() {
    
    		try {
    			if (null == conn) {
    				conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
    			}
    		} catch (SQLException e) {
    			e.printStackTrace();
    			System.err.println("get connection failure");
    		}
    		return conn;
    	}
    
    	/**
    	 * 关闭数据库连接
    	 * 
    	 * @param conn
    	 */
    	private void closeConnection(Connection conn) {
    		if (conn != null) {
    			try {
    				conn.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    				System.err.println("close connection failure");
    			}
    		}
    	}
    
    	/**
    	 * 获取数据库下的所有表名
    	 */
    	private List<String> getTableNames() {
    		List<String> tableNames = new ArrayList<String>();
    		Connection conn = getConnection();
    		ResultSet rs = null;
    		try {
    			// 获取数据库的元数据
    			DatabaseMetaData db = conn.getMetaData();
    			// 从元数据中获取到所有的表名
    			rs = db.getTables(null, null, null, new String[] { "TABLE" });
    			while (rs.next()) {
    				tableNames.add(rs.getString(3));
    			}
    		} catch (SQLException e) {
    			e.printStackTrace();
    			System.err.println("getTableNames failure");
    		} finally {
    			try {
    				if (null != rs) {
    					rs.close();
    				}
    
    			} catch (SQLException e) {
    				e.printStackTrace();
    				System.err.println("close ResultSet failure");
    			}
    		}
    		return tableNames;
    	}
    
    	/**
    	 * 获取表中所有字段名称
    	 * 
    	 * @param tableName
    	 *            表名
    	 * @return
    	 */
    	private List<String> getColumnNames(String tableName) {
    		List<String> columnNames = new ArrayList<String>();
    		// 与数据库的连接
    		Connection conn = getConnection();
    		PreparedStatement pStemt = null;
    		String tableSql = SQL + tableName;
    		try {
    			pStemt = conn.prepareStatement(tableSql);
    			// 结果集元数据
    			ResultSetMetaData rsmd = pStemt.getMetaData();
    			// 表列数
    			int size = rsmd.getColumnCount();
    			for (int i = 0; i < size; i++) {
    				columnNames.add(rsmd.getColumnName(i + 1));
    			}
    		} catch (SQLException e) {
    			System.err.println("getColumnNames failure");
    			e.printStackTrace();
    		} finally {
    			if (pStemt != null) {
    				try {
    					pStemt.close();
    
    				} catch (SQLException e) {
    					e.printStackTrace();
    					System.err.println("getColumnNames close pstem and connection failure");
    				}
    			}
    		}
    		return columnNames;
    	}
    
    	/**
    	 * 获取表中所有字段类型
    	 * 
    	 * @param tableName
    	 * @return
    	 */
    	private List<String> getColumnTypes(String tableName) {
    		List<String> columnTypes = new ArrayList<String>();
    		// 与数据库的连接
    		Connection conn = getConnection();
    		PreparedStatement pStemt = null;
    		String tableSql = SQL + tableName;
    		try {
    			pStemt = conn.prepareStatement(tableSql);
    			// 结果集元数据
    			ResultSetMetaData rsmd = pStemt.getMetaData();
    			// 表列数
    			int size = rsmd.getColumnCount();
    			for (int i = 0; i < size; i++) {
    				columnTypes.add(rsmd.getColumnTypeName(i + 1));
    			}
    		} catch (SQLException e) {
    			e.printStackTrace();
    			System.err.println("getColumnTypes failure");
    		} finally {
    			if (pStemt != null) {
    				try {
    					pStemt.close();
    
    				} catch (SQLException e) {
    					e.printStackTrace();
    					System.err.println("getColumnTypes close pstem and connection failure");
    				}
    			}
    		}
    		return columnTypes;
    	}
    
    	/**
    	 * 
    	 * <p>
    	 * 生成建表语句
    	 * </p>
    	 * 
    	 * @param tableName
    	 * @return
    	 * @author 叶新东(18126064335) 2018年9月6日 上午9:35:49
    	 */
    	private String generateCreateTableSql(String tableName) {
    		String sql = String.format("SHOW CREATE TABLE %s", tableName);
    		Connection conn = null;
    		PreparedStatement pstmt = null;
    		try {
    			conn = getConnection();
    			pstmt = (PreparedStatement) conn.prepareStatement(sql);
    			ResultSet rs = pstmt.executeQuery();
    			while (rs.next()) {
    				// 返回建表语句语句,查询结果的第二列是建表语句,第一列是表名
    				return rs.getString(2);
    
    			}
    
    		} catch (Exception e) {
    			e.printStackTrace();
    			try {
    				if (null != pstmt) {
    					pstmt.close();
    				}
    
    			} catch (Exception e2) {
    				e.printStackTrace();
    				System.err.println("关闭流异常");
    			}
    		}
    		return null;
    	}
    
    	/**
    	 * 获取表中字段的所有注释
    	 * 
    	 * @param tableName
    	 * @return
    	 */
    	private List<String> getColumnComments(String tableName) {
    		// 与数据库的连接
    		Connection conn = getConnection();
    		PreparedStatement pStemt = null;
    		String tableSql = SQL + tableName;
    		List<String> columnComments = new ArrayList<String>();// 列名注释集合
    		ResultSet rs = null;
    		try {
    			pStemt = conn.prepareStatement(tableSql);
    			rs = pStemt.executeQuery("show full columns from " + tableName);
    			while (rs.next()) {
    				columnComments.add(rs.getString("Comment"));
    			}
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} finally {
    			if (rs != null) {
    				try {
    					rs.close();
    
    				} catch (SQLException e) {
    					e.printStackTrace();
    					System.err.println("getColumnComments close ResultSet and connection failure");
    				}
    			}
    		}
    		return columnComments;
    	}
    
    	/**
    	 * 
    	 * <p>
    	 * 备份表数据
    	 * </p>
    	 * 
    	 * @param tableName
    	 * @return
    	 * @author () 2018年9月6日 上午10:18:07
    	 */
    	private String bakTableData(String tableName) {
    
    		Connection conn = null;
    		PreparedStatement pstmt = null;
    		try {
    
    			// 备份建表语句
    			String createTableSql = generateCreateTableSql(tableName);
    			createTableSql = String.format(
    					"\n\n\n/**\n * table name :<%s>\n *\n */\n%s\n",
    					tableName, createTableSql);
    			FileUtils.writeFileContent(filePath, createTableSql);
    			// 获取字段类型
    			List<String> columnTypes = getColumnTypes(tableName);
    			// 获取所有 字段
    			List<String> columnNames = getColumnNames(tableName);
    			String columnArrayStr = null;
    			for (String column : columnNames) {
    				if (null == columnArrayStr) {
    					columnArrayStr = "`" + column + "`";
    				} else {
    					columnArrayStr = columnArrayStr + "," + "`" + column + "`";
    				}
    			}
    
    			String sql = String.format("select %s from %s", columnArrayStr, tableName);
    
    			conn = getConnection();
    			pstmt = (PreparedStatement) conn.prepareStatement(sql);
    			ResultSet rs = pstmt.executeQuery();
    			while (rs.next()) {
    				String rowValues = getRowValues(rs, columnNames.size(), columnTypes);
    				// 返回建表语句语句,查询结果的第二列是建表语句,第一列是表名
    				String insertSql = String.format("insert into %s (%s) values(%s);", tableName, columnArrayStr,
    						rowValues);
    				System.out.println(insertSql);
    				insertSql = insertSql.replaceAll("\n", "<br/>");
    				insertSql = insertSql + "\n";
    				FileUtils.writeFileContent(filePath, insertSql);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    
    			try {
    				if (null != pstmt) {
    					pstmt.close();
    				}
    
    			} catch (Exception e2) {
    				e.printStackTrace();
    				System.err.println("关闭流异常");
    			}
    		}
    		return null;
    	}
    
    	/**
    	 * 
    	 * <p>
    	 * 获取表数据一行的所有值
    	 * </p>
    	 * 
    	 * @param rs
    	 * @param size
    	 * @author  2018年9月6日 上午11:03:05
    	 */
    	private String getRowValues(ResultSet rs, int size, List<String> columnTypeList) {
    		try {
    			String rowValues = null;
    			for (int i = 1; i <= size; i++) {
    				String columnValue = null;
    
    				// 获取字段值
    				columnValue = getValue(rs, i, columnTypeList.get(i - 1));
    				// 如果是空值不添加单引号
    				if (null != columnValue) {
    					columnValue = "'" + columnValue + "'";
    				}
    				// 拼接字段值
    				if (null == rowValues) {
    					rowValues = columnValue;
    				} else {
    					rowValues = rowValues + "," + columnValue;
    				}
    			}
    
    			return rowValues;
    		} catch (Exception e) {
    			e.printStackTrace();
    			System.out.println("获取表数据一行的所有值异常");
    			return null;
    		}
    	}
    
    	/**
    	 * 
    	 * <p>
    	 * 根据类型获取字段值
    	 * </p>
    	 * 
    	 * @param obj
    	 * @return
    	 * @author  2018年9月6日 上午11:16:00
    	 */
    	private String getValue(ResultSet resultSet, Integer index, String columnType) {
    		try {
    
    			if ("int".equals(columnType) || "INT".equals(columnType)) {
    				// 整数
    				Object intValue = resultSet.getObject(index);
    
    				if (null == intValue) {
    					return null;
    				}
    				return intValue + "";
    			} else if ("bigint".equals(columnType) || "BIGINT".equals(columnType)) {
    
    				// 长整形
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("smallint".equals(columnType) || "SMALLINT".equals(columnType)) {
    				// 整数
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("tinyint".equals(columnType) || "TINYINT".equals(columnType)) {
    				// 整数
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("mediumint".equals(columnType) || "MEDIUMINT".equals(columnType)) {
    				// 长整形
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("integer".equals(columnType) || "INTEGER".equals(columnType)) {
    				// 整数
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("float".equals(columnType) || "FLOAT".equals(columnType)) {
    
    				// 浮点数
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("double".equals(columnType) || "DOUBLE".equals(columnType)) {
    				// 浮点数
    				Object value = resultSet.getObject(index);
    				if (null == value) {
    					return null;
    				}
    				return value + "";
    			} else if ("decimal".equals(columnType) || "DECIMAL".equals(columnType)) {
    				// 浮点数-金额类型
    				BigDecimal value = resultSet.getBigDecimal(index);
    				if (null == value) {
    					return null;
    				}
    				return value.toString();
    			} else if ("char".equals(columnType) || "CHAR".equals(columnType)) {
    				// 字符串类型
    				String value = resultSet.getString(index);
    				return value;
    			} else if ("varchar".equals(columnType) || "VARCHAR".equals(columnType)) {
    				// 字符串类型
    				String value = resultSet.getString(index);
    				return value;
    			} else if ("tinytext".equals(columnType) || "TINYTEXT".equals(columnType)) {
    				// 字符串类型
    				String value = resultSet.getString(index);
    				return value;
    			} else if ("text".equals(columnType) || "TEXT".equals(columnType)) {
    				// 字符串类型
    				String value = resultSet.getString(index);
    				return value;
    			} else if ("mediumtext".equals(columnType) || "MEDIUMTEXT".equals(columnType)) {
    				// 字符串类型
    				String value = resultSet.getString(index);
    				return value;
    			} else if ("longtext".equals(columnType) || "LONGTEXT".equals(columnType)) {
    				// 字符串类型
    				String value = resultSet.getString(index);
    				return value;
    			} else if ("year".equals(columnType) || "YEAR".equals(columnType)) {
    				// 时间类型:范围 1901/2155 格式 YYYY
    				String year = resultSet.getString(index);
    				if (null == year) {
    					return null;
    				}
    				// 只需要年的字符即可,
    				return year.substring(0, 4);
    			} else if ("date".equals(columnType) || "DATE".equals(columnType)) {
    				// 时间类型:范围 '1000-01-01'--'9999-12-31' 格式 YYYY-MM-DD
    				return resultSet.getString(index);
    			} else if ("time".equals(columnType) || "TIME".equals(columnType)) {
    				// 时间类型:范围 '-838:59:59'到'838:59:59' 格式 HH:MM:SS
    				return resultSet.getString(index);
    			} else if ("datetime".equals(columnType) || "DATETIME".equals(columnType)) {
    				// 时间类型:范围 '1000-01-01 00:00:00'--'9999-12-31 23:59:59' 格式 YYYY-MM-DD HH:MM:SS
    				return resultSet.getString(index);
    			} else if ("timestamp".equals(columnType) || "TIMESTAMP".equals(columnType)) {
    				// 时间类型:范围 1970-01-01 00:00:00/2037 年某时 格式 YYYYMMDD HHMMSS 混合日期和时间值,时间戳
    				return resultSet.getString(index);
    			} else {
    				return null;
    			}
    
    		} catch (Exception e) {
    			e.printStackTrace();
    			System.err.println("获取数据库类型值异常");
    			return null;
    		}
    	}
    
    	/**
    	 * 
    	 * <开始备份>
    	 * 
    	 * @author  2018年9月6日 下午3:30:43
    	 */
    	public void startBak() {
    		try {
    			List<String> tableNames = getTableNames();
    			System.out.println("tableNames:" + tableNames);
    			for (String tableName : tableNames) {
    				bakTableData(tableName);
    				// System.out.println(generateCreateTableSql(tableName));
    				// System.out.println("ColumnNames:" + getColumnNames(tableName));
    				// System.out.println("ColumnTypes:" + getColumnTypes(tableName));
    				// System.out.println("ColumnComments:" + getColumnComments(tableName));
    			}
    			// 统一关闭连接
    			closeConnection(conn);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	public static void main(String[] args) {
    		new BakDateBase("182.xxx.xxx.xxx", "xd_love_dev", "root", "woaini", "f:\\bak.sql").startBak();
    	}
    }
    

     

     

    执行 main 方法后会在磁盘指定位置生成 .sql  的文件,内容如下:

    展开全文
  • 个人习惯用MySQL workbench EER数据建模,然后生成SQL语句到数据库中执行,这样表之间的关系比较直观。 像下面这样: 画图 正向工程,生成DDL语句: 忽略生成外键,以及外键索引啥的: ...
  • quartz建表语句

    千次阅读 2019-03-05 10:03:26
    建表语句适用2.xx版本.(mysql) -- 存储每一个已配置的 Job 的详细信息 CREATE TABLE QRTZ_JOB_DETAILS( SCHED_NAME VARCHAR(120) NOT NULL, JOB_NAME VARCHAR(200) NOT NULL, JOB_GROUP VARCHAR(200) NOT ...
  • java根据实体类生成mysql建表语句

    千次阅读 2019-07-30 20:59:34
    平时都是创建好表,然后逆向工程生成相应的DO,这次反而突发奇想,就想单纯的写写java,能不能通过用DO生成相应的sql语句,然后加个配置,在系统启动的时候自动创建表呢?胡搞瞎搞走起! 为了方便,随便写个...
  • 需要先将MYSQL的建表语句通过Navicat导出, 具体为, 右键数据库 -> Dump SQL File -> Structure Only 导出仅包含建表语句的SQL文件. 运行下面代码. import java.io.File; import java.util.regex.Matcher; ...
  • 简单地Struts2+hibernate的整合,包含了基本的增删改查,另外写了个登录和注册。可以试试,适合框架初学者。简单 jar包齐全。
  • * 如何从jdbc中获取数据库建表语句信息(表字段名称/表字段类型/表字段注释信息/表字段长度等等) * 1,表字段名称 * 2,表字段类型 * 3,表字段注释信息 这里介绍3种方式,如下: 第一种方式:执行sql语句获取 ...
  • 准备一张维度表:dim_ddl_convert,建表语句如下: DROP TABLE IF EXISTS `dim_ddl_convert`; CREATE TABLE `dim_ddl_convert` ( `source` varchar(100) NOT NULL, `data_type1` varchar(100) NOT NULL, `target`...
  • 由于公司数据库没有进行分库分表,导出上亿数据量时,内存溢出已经解决但是存在速度很慢的问题,在不允许动表情况下还未找到解决办法。 import java.io.BufferedReader; import java.io....import java.io.F
  • 查看建表语句 show create table 表名; 查看当前使用的是哪一个数据库 select database(); 查看当前使用的mysql的版本号 select version(); 强制结束当前SQL语句 Ctrl+c 退出...
  • 找到下载的seata目录下conf文件夹,打开README-zh.md ...- at: AT模式下的 `undo_log` 建表语句 - conf: 客户端的配置文件 - saga: SAGA 模式下所需表的建表语句 - spring: SpringBoot 应用支持的配置文件 ## [server
  • 2.两个类的作用:CreateTable用于建表语句的生成,PackageUtil可以根据报名获取包下所有的类。 3.用法:在CreateTable类中直接给某个类对象即可,如果需要生成某个包下所有的类的建表语句,就借用PackageUtil类即可...
  • mybatis对ClickHouse的支持不是很好,JPA又没有对应的方言,做数仓需要大批量解析JSON数据,希望能自动根据JSONSchema定义来自动建表,节省工作量,并且不用为了复杂JSON建对象,还要服务发版。这个工具应用场景可能...
  • 建表sql语句(mysql)

    2012-09-12 22:10:29
    配套的医院管理系统语句,记得mysql的密码和用户名在医院管理系统的mysql的属性文件中更改即可,将sql语句放在sqlyog执行即可创建对应的表和插入对应的数据
  • 读取表头会触发一次Action,如果自动推导数据类型还会再触发一次Action,而且会全表检索,因为它需要判断后面的每行数据的每个字段是否都是同一数据类型的,那么这样自动推导数据类型就会十分浪费运行速度,所以最佳的...
  • 最简单的mybatis实例,jar包齐全,执行数据库查询,带建表语句,只需在可用的mysql数据库中建表,即可运行
  • java poi EXCLE 导入/导出 EXCLE 导入 EXCLE导出 poi 导入/导出 源代码+数据库建表语句+测试数据 mysql下建库表 源代码导入eclipse 直接运行 畅通无阻 OK!!!
  • 基本util工具类已完成,实现如下功能, 完成对json报文格式解析; 根据提供的json报文标准接口规范生成对应... 生成建表语句,支持Oracle,MySQL(主) 图一是原xml报文结构(后续实际以json报文格式为主)...
  • 执行DDL语句(创建表)

    千次阅读 2019-10-26 18:49:10
    执行SQL语句 释放资源 创建表和异常处理 案例 : 创建学生信息表(t_student) .包含 id/name/age 三个列 。 SQL : create table tk_student( id bigint primary key auto_increment,name varchar(20),...
  • 这两天在开发一个导出odps建表语句的功能,参考链接https://bbs.aliyun.com/read/247201.html?spm=a2c4e.11155507.0.0.1a3c2edb5oZVK8 但是上传到服务器进行测试后,发现执行到Table相关的方法时,就自动retry了。...
  • Hive建表语句详解--CREATE TABLE

    万次阅读 多人点赞 2019-01-09 15:05:00
    要为表指定数据库,请在CREATE TABLE语句之前(在Hive 0.6及更高版本中)发出USE database_name语句,或者使用数据库名称(在Hive 0.7及更高版本中使用“ ” )限定表名。关键字“ ”可用于默认数据库。database_...
  • ls /opt/hive/tables/tablesDDL/*.txt |while read line do # hive -f $line #这种方式如果中间建表错误,就会中断,导致后面的表不能创建 beeline -u jdbc:hive2://hdh02.c.p.xyidc:10000 -n data -p az -f $line ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,782
精华内容 11,512
关键字:

java执行建表语句

java 订阅