根据Excel接口文档生成不同类型的数据创建表的sql

已于 2023-06-13 07:41:15 修改
阅读量1.1k 收藏 5
点赞数 2
分类专栏： springboot 文章标签： sql spring boot mybatisplus
于 2022-08-29 23:20:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37400096/article/details/126594269
版权

文章目录

背景

在平时开发接口的时候，经常会根据接口文档将数据插入第三方数据库的情况，本篇我们介绍一下，读取excel将字段提取出来生成创表的sql。非常适用。

快速开始

话不多说，直接上代码。
表和列实体类

**
 * 实体表信息
 */
@Data
@TableName("`table_entity`")
public class TableEntity {

    @TableId(value = "table_id", type = IdType.AUTO)
    private Integer tableId;
    //表名
    @TableField(value = "table_name")
    private String tableName;
    //表注释
    @TableField(value = "table_comment")
    private String tableComment;
    //数据库名
    @TableField(value = "db_name")
    private String databaseName;
    //数据库类型 ORACLE,MSSQL,MYSQL
    @TableField(value = "db_type")
    private String databaseType;

    //数据库SCHEMA
    @TableField(value = "table_schema")
    private String tableSchema;

    //实体列名字
    private List<ColumnEntity> tableColumns;

@Data
@TableName("`column_entity`")
public class ColumnEntity {
    @TableId(value = "column_id", type = IdType.AUTO)
    @ExcelProperty(value="序号")
    private Integer columnId;
    //表的ID
    @ExcelProperty(value="表名ID")
    @TableField("table_id")
    private Integer tableId;
    //列名
    @ExcelProperty(value="列名")
    @TableField("column_name")
    private String columnName;
    //列注释
    @ExcelProperty(value="列注释")
    @TableField("column_desc")
    private String ColumnDesc;
    //类型
    @ExcelProperty(value="数据类型")
    @TableField("column_type")
    private String columnType;
    //长度
    @ExcelProperty(value="长度")
    @TableField("column_len")
    private String columnLen;
    //精度
    @ExcelProperty(value="精度")
    @TableField("precision")
    private String precision;
    //是否主键 Y true 都默认是主键
    @ExcelProperty(value="是否主键")
    @TableField("isPrimaryKey")
    private String isPrimaryKey;
    //是否允许为空 Y true 不允许为空
    @ExcelProperty(value="是否允许为空")
    @TableField("isNotNull")
    private String isNotNull;
    //是否索引列，方便进行生成建表语句的时候进行生成索引
    @ExcelProperty(value="是否索引列")
    @TableField("isIdxCol")
    private String isIdxCol;
}

建表语句

-- test.table_entity definition

CREATE TABLE `table_entity` (
  `table_id` int NOT NULL AUTO_INCREMENT COMMENT '表主键',
  `table_name` varchar(100) NOT NULL COMMENT '表名',
  `table_comment` varchar(200) DEFAULT NULL COMMENT '表注释',
  `db_name` varchar(10) DEFAULT NULL COMMENT '表对应的数据库名字',
  `db_type` varchar(10) DEFAULT NULL COMMENT '数据库类型',
  `table_schema` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '表对应的schema',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `create_by` varchar(100) DEFAULT NULL COMMENT '创建人',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
  `update_by` varchar(100) DEFAULT NULL COMMENT '更新人',
  PRIMARY KEY (`table_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='表实体信息';
-- test.column_entity definition

CREATE TABLE `column_entity` (
  `column_id` int NOT NULL AUTO_INCREMENT COMMENT '列序号',
  `table_id` int NOT NULL COMMENT '表信息ID',
  `column_name` varchar(100) NOT NULL COMMENT '列名',
  `column_desc` varchar(100) DEFAULT NULL COMMENT '列注释',
  `column_type` varchar(100) NOT NULL COMMENT '数据类型',
  `column_len` int DEFAULT NULL COMMENT '列长度',
  `precision` int DEFAULT NULL COMMENT '精度',
  `isPrimaryKey` varchar(1) DEFAULT NULL COMMENT '是否是主键',
  `isNotNull` varchar(1) DEFAULT NULL COMMENT '是否允许为空',
  `isIdxCol` varchar(1) DEFAULT NULL COMMENT '是否索引列',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `create_by` varchar(10) DEFAULT NULL COMMENT '创建人',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
  `update_by` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '更新人',
  PRIMARY KEY (`column_id`),
  KEY `column_entity_column_name_IDX` (`column_name`) USING BTREE,
  KEY `column_entity_FK` (`table_id`),
  CONSTRAINT `column_entity_FK` FOREIGN KEY (`table_id`) REFERENCES `table_entity` (`table_id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='列信息表';

mapper类接口

/**
 * 表实体信息映射
 */
@Mapper
public interface TableEntityMapper extends BaseMapper<TableEntity> {

}
/**
 * 实体类映射接口
 */
@Mapper
public interface ColumnEntityMapper extends BaseMapper<ColumnEntity> {


}

创建表辅助类

目前写的支持mysql,sqlsever,oracle，需要可以自行修改，代码可以合并一下，现在分开的。

package com.elite.springboot.utils;

import com.elite.springboot.entity.ColumnEntity;
import com.elite.springboot.entity.ColumnTypeConstant;
import com.elite.springboot.entity.TableEntity;

import java.util.List;

/**
 * 创建表辅助类
 * create database.table(
 *   column type  isprimarykey isnull default comment '',
 *   column2 type ,
 *   ....
 * )
 *  列顺序
 *  1.mysql:  字段 类型 约束  默认值  注释
 *  2.oracle: 字段 类型 约束  默认值  注释单独进行拼接一个串。
 *  3.mssql:
 */
public class CreateTableHelper {
    /**
     * @Param:将实体类转换为mysql创表的sql
     * @return:
     */
    public static String getMysqlSqlByConvertEntity(TableEntity tableEntity) {
        StringBuffer sql = new StringBuffer();
        //存在则删除表
        sql.append("DROP TABLE IF EXISTS "+tableEntity.getTableName()+";");
        sql.append("CREATE TABLE `");
        sql.append(tableEntity.getDatabaseName());
        sql.append("`.`");
        sql.append(tableEntity.getTableName());
        sql.append("` (");
        // CREATE TABLE `databaseName`.`tablePhysicalName` (
        List<ColumnEntity> columns = tableEntity.getTableColumns();
        // 主键列
        String primaryKeyColumn = null;
        //
        int i = 0;
        // 获取主键
        for (ColumnEntity column : columns) {
            // 将pk为true的设为主键
            if ("true".equals(column.getIsPrimaryKey()) || "Y".equals(column.getIsPrimaryKey())) {
                primaryKeyColumn = column.getColumnName();
                break;
            }
        }
        //循环列拼接动态的sql的顺序：
        //1.mysql:  字段 类型 约束  默认值  注释
        //2.oracle: 字段 类型 约束  默认值  注释单独进行拼接一个串。
        //3.mssql:
        for (ColumnEntity column : columns) {
            sql.append(" `");
            sql.append(column.getColumnName().trim());
            sql.append("` ");
            // `physicalColumnName`
            // 根据NOT NULL 来拼接
            if ("Y".equals(column.getIsNotNull()) || "true".equals(column.getIsNotNull())) { // 如果不允许为空，则拼接NOT NULL
                //类型
                String type = column.getColumnType().toLowerCase();
                if (type.indexOf("varchar") != -1) {
                    type = ColumnTypeConstant.VARCHAR;
                } else if (type.indexOf("number") != -1) {
                    type = ColumnTypeConstant.INT;
                    //默认长度
                    if (column.getColumnLen() == null || column.getColumnLen().isEmpty()) {
                        column.setColumnLen("11");
                    }
                } else if (type.indexOf("char") != -1) {
                    type = ColumnTypeConstant.CHAR;
                }
                // 根据类型选择是否拼接长度
                if (ColumnTypeConstant.CHAR.equals(type) || ColumnTypeConstant.VARCHAR.equals(type)) { // 文本需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(") CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '");
                } else if (ColumnTypeConstant.TEXT.equals(type) || ColumnTypeConstant.LONG_TEXT.equals(type)) { // 文本不需要拼接长度
                    sql.append(type);
                    sql.append(" CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '");
                } else if (ColumnTypeConstant.DATE.equals(type)) { // 时间不需要拼接长度
                    sql.append(type);
                    sql.append(" NOT NULL COMMENT '");
                } else if (ColumnTypeConstant.DATE_TIME.equals(type) || ColumnTypeConstant.TIME_STAMP.equals(type)) { // 时间需要拼接长度 并且长度为0
                    sql.append(type);
                    sql.append("(0) NOT NULL COMMENT '");
                } else if (ColumnTypeConstant.INT.equals(type)) { // 数字需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(")  NOT NULL COMMENT '");
                }
            } else { // 如果允许为空，则拼接 NULL DEFAULT NULL
                String type = column.getColumnType().toLowerCase();
                //类型转换
                if (type.indexOf("varchar") != -1) {
                    type = ColumnTypeConstant.VARCHAR;
                } else if (type.indexOf("number") != -1) {
                    type = ColumnTypeConstant.INT;
                    //默认长度
                    if (column.getColumnLen() == null || column.getColumnLen().isEmpty()) {
                        column.setColumnLen("11");
                    }
                } else if (type.indexOf("char") != -1) {
                    type = ColumnTypeConstant.CHAR;
                }
                // 根据类型选择是否拼接长度
                if (ColumnTypeConstant.CHAR.equals(type) || ColumnTypeConstant.VARCHAR.equals(type)) { // 文本需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(") CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '");
                } else if (ColumnTypeConstant.TEXT.equals(type) || ColumnTypeConstant.LONG_TEXT.equals(type)) { // 文本不需要拼接长度
                    sql.append(type);
                    sql.append(" CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '");
                } else if (ColumnTypeConstant.DATE.equals(type)) { // 时间不需要拼接长度
                    sql.append(type);
                    sql.append(" NULL DEFAULT NULL COMMENT '");
                } else if (ColumnTypeConstant.DATE_TIME.equals(type) || ColumnTypeConstant.TIME_STAMP.equals(type)) { // 时间需要拼接长度 并且长度为0
                    sql.append(type);
                    sql.append("(0) NULL DEFAULT NULL COMMENT '");
                } else if (ColumnTypeConstant.INT.equals(type) || ColumnTypeConstant.BIGINT.equals(type) || ColumnTypeConstant.LONG.equals(type)) { // 数字需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(")  NULL DEFAULT NULL COMMENT '");
                }
            }
            i++;
            // 拼接逻辑列名/如果为最后一个字段就不拼接，
            if (columns.size() == i && primaryKeyColumn == null) {
                sql.append(column.getColumnDesc());
                sql.append("'");
            } else {
                sql.append(column.getColumnDesc());
                sql.append("',");
            }
        }
        // 拼接主键
        if (primaryKeyColumn != null) {
            sql.append(" PRIMARY KEY (`");
            sql.append(primaryKeyColumn);
            sql.append("`) USING BTREE ) ");
        } else {
            sql.append(") ");
        }
        // 拼接引擎和逻辑表名
        sql.append("ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '");
        sql.append(tableEntity.getTableComment());
        sql.append("'  ROW_FORMAT = Compact;");
        System.out.println(sql.toString());
        return sql.toString();
    }
    /**
     * @Param:将实体类转换为oracle创表的sql
     * @return:
     */
    public static String getOracleSqlByConvertEntity(TableEntity tableEntity) {
        StringBuffer sql = new StringBuffer();
        //删表默认注释掉
        sql.append("--DROP TABLE "+tableEntity.getTableName()+";");
        StringBuffer comments = new StringBuffer();
        sql.append("CREATE TABLE `");
        sql.append(tableEntity.getDatabaseName());
        sql.append("`.`");
        sql.append(tableEntity.getTableName());
        sql.append("` (");
        // CREATE TABLE `databaseName`.`tablePhysicalName` (
        List<ColumnEntity> columns = tableEntity.getTableColumns();
        //获取表名注释
        comments.append("COMMENT ON TABLE "+ tableEntity.getTableName()+" is '"+tableEntity.getTableComment() +"';");
        // 主键列
        String primaryKeyColumn = null;
        int i = 0;
        // 获取主键
        for (ColumnEntity column : columns) {
            // 将pk为true的设为主键
            if ("true".equals(column.getIsPrimaryKey()) || "Y".equals(column.getIsPrimaryKey())) {
                primaryKeyColumn = column.getColumnName();
                break;
            }
        }
        //循环列拼接动态的sql的顺序：
        //1.mysql:  字段 类型 约束  默认值  注释
        //2.oracle: 字段 类型 约束  默认值  注释单独进行拼接一个串。
        //3.mssql:
        for (ColumnEntity column : columns) {
            sql.append(" `");
            sql.append(column.getColumnName().trim());
            sql.append("` ");
            // `physicalColumnName`
            // 根据NOT NULL 来拼接
            if ("Y".equals(column.getIsNotNull()) || "true".equals(column.getIsNotNull())) { // 如果不允许为空，则拼接NOT NULL
                //类型
                String type = column.getColumnType().toLowerCase();
                if (type.indexOf("varchar") != -1) {
                    type = ColumnTypeConstant.VARCHAR;
                } else if (type.indexOf("number") != -1) {
                    type = ColumnTypeConstant.INT;
                    //默认长度
                    if (column.getColumnLen() == null || column.getColumnLen().isEmpty()) {
                        column.setColumnLen("11");
                    }
                } else if (type.indexOf("char") != -1) {
                    type = ColumnTypeConstant.CHAR;
                }
                // 根据类型选择是否拼接长度
                if (ColumnTypeConstant.CHAR.equals(type) || ColumnTypeConstant.VARCHAR.equals(type)) { // 文本需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(")");
                } else if (ColumnTypeConstant.TEXT.equals(type) || ColumnTypeConstant.LONG_TEXT.equals(type)) { // 文本不需要拼接长度
                    sql.append(type);
                    sql.append(" '");
                } else if (ColumnTypeConstant.DATE.equals(type)) { // 时间不需要拼接长度
                    sql.append(type);
                    sql.append(" NOT NULL ");
                } else if (ColumnTypeConstant.DATE_TIME.equals(type) || ColumnTypeConstant.TIME_STAMP.equals(type)) { // 时间需要拼接长度 并且长度为0
                    sql.append(type);
                    sql.append("(0) NOT NULL ");
                } else if (ColumnTypeConstant.INT.equals(type)) { // 数字需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(")  NOT NULL ");
                }
            } else { // 如果允许为空，则拼接 NULL DEFAULT NULL
                String type = column.getColumnType().toLowerCase();
                //类型转换
                if (type.indexOf("varchar") != -1) {
                    type = ColumnTypeConstant.VARCHAR;
                } else if (type.indexOf("number") != -1) {
                    type = ColumnTypeConstant.INT;
                    //默认长度
                    if (column.getColumnLen() == null || column.getColumnLen().isEmpty()) {
                        column.setColumnLen("11");
                    }
                } else if (type.indexOf("char") != -1) {
                    type = ColumnTypeConstant.CHAR;
                }
                // 根据类型选择是否拼接长度
                if (ColumnTypeConstant.CHAR.equals(type) || ColumnTypeConstant.VARCHAR.equals(type)) { // 文本需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(") ");
                } else if (ColumnTypeConstant.TEXT.equals(type) || ColumnTypeConstant.LONG_TEXT.equals(type)) { // 文本不需要拼接长度
                    sql.append(type);
                    sql.append(" ");
                } else if (ColumnTypeConstant.DATE.equals(type)) { // 时间不需要拼接长度
                    sql.append(type);
                    sql.append(" ");
                } else if (ColumnTypeConstant.DATE_TIME.equals(type) || ColumnTypeConstant.TIME_STAMP.equals(type)) { // 时间需要拼接长度 并且长度为0
                    sql.append(type);
                    sql.append("(0) ");
                } else if (ColumnTypeConstant.INT.equals(type) || ColumnTypeConstant.BIGINT.equals(type) || ColumnTypeConstant.LONG.equals(type)) { // 数字需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(") ");
                }
            }
            i++;
            // 拼接逻辑列名/如果为最后一个字段就不拼接，
            if (columns.size() == i && primaryKeyColumn == null) {
                sql.append("");
            } else {
                sql.append(",");
            }
            //每一列的注释
            comments.append( "COMMENT ON COLUMN "+tableEntity.getTableName()+"."+column.getColumnName()+" IS '" + column.getColumnDesc()+"';");
        }
        // 拼接主键
        if (primaryKeyColumn != null) {
            sql.append(" PRIMARY KEY (`");
            sql.append(primaryKeyColumn);
            sql.append("`)); ");
        } else {
            sql.append(") ;");
        }
        System.out.println("sql:"+sql.toString());
        System.out.println("comment:"+comments.toString());
        return sql.toString()+comments.toString();
    }
    /**
     * @Param:将实体类转换为mssql创表的sql
     * @return:
     */
    public static  String getMSSQLSqlByConvertEntity(TableEntity tableEntity) {



        //建表字段的sql
        StringBuffer sql = new StringBuffer();
        //判断是否存在存在进行删除
        sql.append("IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].["+tableEntity.getTableName()+"]') AND type in (N'U')");
        sql.append("DROP TABLE [dbo].["+tableEntity.getTableName()+"];");
        sql.append("[dbo].["+tableEntity.getTableName()+"]");


        //表注释
        StringBuffer comments = new StringBuffer();
        comments.append("EXEC sp_addextendedproperty 'MS_Description', '"+tableEntity.getTableComment()+"', 'SCHEMA', dbo, 'table', "+tableEntity.getTableName()+", null, null;");


        // CREATE TABLE `databaseName`.`tablePhysicalName` (
        List<ColumnEntity> columns = tableEntity.getTableColumns();
        // 主键列
        String primaryKeyColumn = null;
        //
        int i = 0;
        // 获取主键
        for (ColumnEntity column : columns) {
            // 将pk为true的设为主键
            if ("true".equals(column.getIsPrimaryKey()) || "Y".equals(column.getIsPrimaryKey())) {
                primaryKeyColumn = column.getColumnName();
                break;
            }
        }
        //循环列拼接动态的sql的顺序：
        for (ColumnEntity column : columns) {
            sql.append(" `");
            sql.append(column.getColumnName().trim());
            sql.append("` ");
            // `physicalColumnName`
            // 根据NOT NULL 来拼接
            if ("Y".equals(column.getIsNotNull()) || "true".equals(column.getIsNotNull())) { // 如果不允许为空，则拼接NOT NULL
                //类型
                String type = column.getColumnType().toLowerCase();
                if (type.indexOf("varchar") != -1) {
                    type = ColumnTypeConstant.VARCHAR;
                } else if (type.indexOf("number") != -1) {
                    type = ColumnTypeConstant.INT;
                    //默认长度
                    if (column.getColumnLen() == null || column.getColumnLen().isEmpty()) {
                        column.setColumnLen("11");
                    }
                } else if (type.indexOf("char") != -1) {
                    type = ColumnTypeConstant.CHAR;
                }
                // 根据类型选择是否拼接长度
                if (ColumnTypeConstant.CHAR.equals(type) || ColumnTypeConstant.VARCHAR.equals(type)) { // 文本需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(")");
                } else if (ColumnTypeConstant.TEXT.equals(type) || ColumnTypeConstant.LONG_TEXT.equals(type)) { // 文本不需要拼接长度
                    sql.append(type);
                    sql.append(" ");
                } else if (ColumnTypeConstant.DATE.equals(type)) { // 时间不需要拼接长度
                    sql.append(type);
                    sql.append(" NOT NULL");
                } else if (ColumnTypeConstant.DATE_TIME.equals(type) || ColumnTypeConstant.TIME_STAMP.equals(type)) { // 时间需要拼接长度 并且长度为0
                    sql.append(type);
                    sql.append("(0) NOT NUL");
                } else if (ColumnTypeConstant.INT.equals(type)) { // 数字需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(")  NOT NULL");
                }
            } else { // 如果允许为空，则拼接 NULL DEFAULT NULL
                String type = column.getColumnType().toLowerCase();
                //类型转换
                if (type.indexOf("varchar") != -1) {
                    type = ColumnTypeConstant.VARCHAR;
                } else if (type.indexOf("number") != -1) {
                    type = ColumnTypeConstant.INT;
                    //默认长度
                    if (column.getColumnLen() == null || column.getColumnLen().isEmpty()) {
                        column.setColumnLen("11");
                    }
                } else if (type.indexOf("char") != -1) {
                    type = ColumnTypeConstant.CHAR;
                }
                // 根据类型选择是否拼接长度
                if (ColumnTypeConstant.CHAR.equals(type) || ColumnTypeConstant.VARCHAR.equals(type)) { // 文本需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(") ");
                } else if (ColumnTypeConstant.TEXT.equals(type) || ColumnTypeConstant.LONG_TEXT.equals(type)) { // 文本不需要拼接长度
                    sql.append(type);
                    sql.append(" ");
                } else if (ColumnTypeConstant.DATE.equals(type)) { // 时间不需要拼接长度
                    sql.append(type);
                    sql.append(" ");
                } else if (ColumnTypeConstant.DATE_TIME.equals(type) || ColumnTypeConstant.TIME_STAMP.equals(type)) { // 时间需要拼接长度 并且长度为0
                    sql.append(type);
                    sql.append("(0)  ");
                } else if (ColumnTypeConstant.INT.equals(type) || ColumnTypeConstant.BIGINT.equals(type) || ColumnTypeConstant.LONG.equals(type)) { // 数字需要拼接长度
                    sql.append(type);
                    sql.append("(");
                    sql.append(column.getColumnLen());
                    sql.append(") ");
                }
            }
            i++;
            // 拼接逻辑列名/如果为最后一个字段就不拼接，
            if (columns.size() == i && primaryKeyColumn == null) {
            } else {
                sql.append(",");
            }
            //追加注释表的sql
            comments.append("EXEC sp_addextendedproperty 'MS_Description', '"+column.getColumnDesc()+"', 'SCHEMA', dbo, 'table', "+tableEntity.getTableName()+", 'column', "+column.getColumnName()+";");
        }
        // 拼接主键
        if (primaryKeyColumn != null) {
            sql.append(", PRIMARY KEY (`");
            sql.append(primaryKeyColumn);
            sql.append("`); ");
        } else {
            sql.append("); ");
        }
        System.out.println(sql.toString());
        System.out.println(comments.toString());
        return sql.toString()+comments.toString();
    }
}

测试

保存信息到数据库

@Test
    public void test(){

        //插入主表ID
        TableEntity tableEntity = new TableEntity();
        tableEntity.setTableName("table1");
        tableEntity.setTableComment("测试表");
        tableEntity.setDatabaseName("test");
        tableEntity.setDatabaseType("mysql");
        tableEntity.setTableSchema("");
        tableEntityMapper.insert(tableEntity);

        ColumnEntity columnEntity = new ColumnEntity();
        columnEntity.setColumnName("test");
        columnEntity.setTableId(1);
        columnEntity.setColumnDesc("测试列");
        columnEntity.setColumnType("int");
        columnEntity.setColumnLen("30");
        columnEntity.setIsPrimaryKey("Y");
        columnEntity.setIsNotNull("N");
        columnEntityMapper.insert(columnEntity);

    }

生成sql

@Test
    public void shouldAnswerWithTrue() {
        List<ColumnEntity> columns = new ArrayList<>();
        ColumnEntity column1 = new ColumnEntity();
        column1.setColumnName("id");
        column1.setColumnDesc("主键");
        column1.setColumnType("int");
        column1.setColumnLen("30");
        column1.setIsPrimaryKey("Y");
        column1.setIsNotNull("true");
        ColumnEntity column2 = new ColumnEntity();
        column2.setColumnName("name");
        column2.setColumnDesc("姓名");
        column2.setColumnType("varchar");
        column2.setColumnLen("50");
        column2.setIsPrimaryKey("N");
        column2.setIsNotNull("N");
        //添加列1
        columns.add(column1);
        //添加列2
        columns.add(column2);
        //表实体类
        TableEntity tableEntity = new TableEntity();
        tableEntity.setTableName("testtable");
        tableEntity.setTableComment("测试表");
        tableEntity.setTableColumns(columns);
        tableEntity.setDatabaseName("testdb");

        //输出mysqlSql
        //String mysqlSql = CreateTableHelper.getMysqlSqlByConvertEntity(tableEntity);

        //输出oracelSql
        String oracelSql = CreateTableHelper.getOracleSqlByConvertEntity(tableEntity);
        System.out.println(oracelSql);

    }

在这里插入图片描述

小刘同学要加油呀
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
根据Word接口文档生成建表SQL语句工具
迷失蒲公英
03-24 328
上篇讲到基于工作的需要，实现根据word接口文档生成Java实体代码工具，同理，数据需要持久化到数据库表，如果字段很多，一个一个字段手工添加到数据库也是很麻烦的，所以我们同样需要一款能实现。以上就是根据Word接口文档生成建表SQL语句工具的使用方法，有需要的朋友可以试试。我们的备注字段有可能想进行定制，这里我们定制为“数据项名称+\n+说明”3.选择字段名列、字段类型列、字段长度列、字段备注列，5.点击生成，即可生成对应的建表SQL语句。
DbTool:数据库工具，根据表结构文档生成创建表sql，根据数据库表信息导出Model和表结构文档，根据文档生成数据库表，根据已有Model文件生成创建数据库表sql
05-11
DbTool 一个支持 DbFirst、ModelFirst 和 CodeFirst 的数据库工具。 简介 这是一个针对 SqlServer 和 C# 的数据库的小工具，可以利用这个小工具生成数据库表对应的 Model，并且会判断数据表列是否可以为空，可以为空的情况下会使用可空的数据类型，如 int? , DateTime? ，如果数据库中有列描述信息，也会生成在属性名称上添加列描述的注释，支持导出多个表；可以导出到Excel，可以根据Excel字段文档生成Sql，数据库表误删除又没有备份的时候就很有帮助了，而且支持反向的根据生成的Model去生成创建数据库表的Sql。 注：暂时不支持索引及外键等需要关联另外一张表的数据关系 为什么使用它 根据表字段信息生成创建表 Sql（Model First） 导入 Excel 文件生成创建表的 Sql（Model First） 根据数据库表信息
excel自动生成创建表sql语句，支持MySql，Oracle，SQLServer三种创建方式，方便管理
01-18
excel自动生成创建表语句，支持MySql，Oracle，SQLServer三种创建方式，自动生成目录文档，方便查看与管理。
excel自动生成创建表语句mysql，sqlserver.xlsm
10-24
excel中支持mysql（主键自增），sqlserver自动创建表语句，方便文档留存查看。oracle也写了宏指令，用office打开文档，按alt+F11自行改宏代码。
python脚本，根据excel数据自动创建mysql库、表-并更新数据
01-07
python3.7.4版本，文件包含excel文件和py文件。 py文件中需要手动设置excel字段在mysql中的类型、index索引及写入时校验的字段。（搜索*查找对应的位置） 执行py文件，若不存在数据库及表会自动创建，并写入数据（对于指定字段重复的不会写入）
使用Python将按照某种特定格式的属性表excel文件动态生成建表SQL语句(使用Pandas库)
得未曾有 心净踊跃
03-26 2044
问题描述 有33个国标属性表excel文件，需要根据这些标准属性表来建数据库表。 每个excel的格式大概如下： 对于这样的繁重且基本无脑的活，我选择用Python来搞定： 代码 import pandas import re def getStandardDataType(x): x = x.replace(" ", "") x = x.replace("，", ",") x = x.replace("（", "(") x = x.replace("）", ")")
根据Excel文件生成数据库insert建表sql
05-28
1、不需要运行代码，只需要按照模板编写业务表字段即可，然后在Excel中点击生成DDL即可生成建表sql； 2、方便可视化sql表字段展示，统一维护，可放在钉钉、teams、云盘中共同维护，方便版本管理，生成最新的表结构； 3、对项目开始设计表时特别友好，方便统一管理表字段，也方便和业务确认字段； 4、具体操作步骤可见资源目录：使用说明.pdf； 5、资源使用有问题可私信联系；
Java poi 用excel生成sql文件建表
ccccm__的博客
03-08 701
在编写文档的时候想着直接把文档变成表结构，可以减少工作量，于是写了这个工具类。
Java读取excel文件生成创建表、插入数据sql
tanqingfu1的博客
05-11 1358
目录 1、添加依赖 2、实际测试代码 3、返回的数 1、添加依赖 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>4.0.0</version> </dependency> <dependency> <groupId>org.apache.poi&l
根据excel生成create建表SQL语句
热门推荐
weixin_43165220的博客
11-24 1万+
我平时创建数据库表的时候，都是习惯先用记事本将要用到的字段列出来，写好字段名和注释，像这种 然后用代码读取这个文本，通过中文冒号：分隔，获取到名称和注释，再通过create建表语句，将字段名、注释拼接起来，生成sql输出。这样生成的没有考虑到字段类型、长度，需要建完表后再设置。 然后今天闲来无事，想着得规范一下，在列要用到的字段的时候，就将类型和长度也设计好，执行完sql之后就不用一个一个去改了。所以我用的是excel表格（比较好看），像这样 行数不限，列数只有四列，第一行必须是 表注释:表名，用英文
Excel自动生成sql创建表语句
01-17
支持sqlserver与oracle自动生成sql创建表语句，一键自动生成，非常强大。
用Excel快速创建建表sql
10-10
用Excel快速创建建表sql
EXCEL生成建表SQL的脚本（SQL Server）
fanny__的博客
10-24 1594
Sub createSingle_Click() Dim sql As String Dim tableName As String Dim comm As String Set fs = CreateObject("Scripting.FileSystemObject") sFilePath = ActiveWorkbook.Path & "\Script\" If Dir(...
根据Excel配置表单自动生成mysql创建表sql语句
ylq1045的专栏
03-09 4945
开发了一个小工具，根据Excel表单来自动生成创建mysql的语句 使用NPOI来操作Excel
根据Excel文件生成创建表的Sql(目前仅支持mysql和sqlserver)
guoshunwgs
03-12 2738
使用DbTool工具根据Excel文件生成创建表的Sql 支持mysql和sqlserver DbTool使用指南 DbTool工具下载地址
excel自动生成创建表sql语句
qq_41373328的博客
01-18 9442
Sub 选项按钮4_Click() Dim sqlStr, sqlTemp, pkStr, columnName, columnType, columnLength, isPk, notExistTable, isNull, comment As String Dim tableListIndex, columnListIndex As Integer Dim a...
根据Excel生成建表语句sql——源码设计说明
忙碌的菠萝
12-13 1526
根据Excel生成建表语句sql 设计的人跟开发的人总不是同一个，这就导致了设计是设计的思路，开发是开发的思路，表也是一样，开发给加了字段不同步给设计人员，设计加了字段开发可能这个环境加了，另一个没加。为了避免比对和扯皮，以设计为准！ 生成思路 设计为标准的excel表，可以用java读取excel内容，再根据内容填入固定vm模板中，最后生成sql语句。 批量的话就是循环读取多张Excel sheet页，然后循环生成到一个文件即可 工程结构如下 Excel读取部分代码 public static List
根据hdfs文件创建表
qq_23519469的博客
07-12 655
根据hdfs文件创建表
oracle生成表结构文档
最新发布
12-13
生成的文档将包含表的详细信息，包括表名、列名、数据类型、约束、索引等等。可以根据需要选择生成的内容。 生成的文档可以保存为HTML、PDF、Excel等格式，方便查看和分享。 除了PL/SQL Developer，还有其他工具和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小刘同学要加油呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值