MySql建表脚本转CK

前置知识

主要是类型的转换、和空、非空的问题

整形

• ClickHouse则直接使用Int8、Int16、Int32和Int64指代4种大小的Int类型，其末尾的数字正好表明了占用字节的大小（8位=1字节）

• mysql中: int(M)的作用于int的范围明显是无关的，int(M)只是用来显示数据的宽度，我们能看到的宽度。当字段被设计为int类型，那么它的范围就已经被写死了(-2147483648~2147483647),与M无关。

CK的NOT NULL、NULL和Nullable的区别

1. 如果字段声明为 not null它的默认值已由它的类型而定，不允许再为其设置默认值,比如int为0，String为空串。不需要显式声明
2. 如果字段显式声明为null，默认值为NULL。
3. 如果字段声明为Nullable，默认为NULL，可设置默认值，损耗性能。

/**
 * @Author yhchen
 * @Date 2022/3/8 10:22
 */
public class MysqlToCK2 {
    public static void main(String[] args) {
    //将sql复制到这里
        String createTable = "DROP TABLE IF EXISTS `runoob_tbl`;\n" +
                "CREATE TABLE IF NOT EXISTS `runoob_tbl`(\n" +
                "   `runoob_id` int UNSIGNED AUTO_INCREMENT,\n" +
                "   `runoob_title` VARCHAR(100) NOT NULL,\n" +
                "   `runoob_author` VARCHAR(40) NOT NULL,\n" +
                "   `submission_date` DATE,\n" +
                "   PRIMARY KEY ( `runoob_id` )\n" +
                ")ENGINE=InnoDB DEFAULT CHARSET=utf8;";
        System.out.println("请检查语句,不要有空行 也就是只有'\\n'");
        String res = changeMysqlTableToClickHouse(createTable);
        System.out.println("转换后的建表语句为：");
        System.out.println(res);
        System.out.println("需要删除ENGINE的上一行最后的一个逗号");
    }

    public static String changeMysqlTableToClickHouse(String tableName) {
        String tables = tableName;
        String primaryKey = "`id`";//默认id
        String[] rows = tables.split("\n");
        StringBuilder replaceTables = new StringBuilder();
        Boolean haveKey = false;
        int i = 0;
        for (String row : rows) {
            // 注释，不处理
            if (row.contains("--")) {
                replaceTables.append(row + "\n");
                continue;
            }
            if (row.contains("KEY")) {
                if (row.contains("PRIMARY")) {
                    haveKey = true;
                    primaryKey = row.substring(row.indexOf("(") + 1, row.indexOf(")"));
                }
                // 跳过、不添加
                continue;
            }
            if (row.contains("ENGINE=InnoDB")) {
                // 引擎替换
                row = ") ENGINE = ReplacingMergeTree";
            }

            // 无关删除
            String changeRow = row.replaceAll("AUTO_INCREMENT", "")
                    .replaceAll("CHARACTER SET utf8mb4", "")
                    .replaceAll("CHARACTER SET utf8", "")
                    .replaceAll("ON UPDATE CURRENT_TIMESTAMP", "")
                    .replaceAll("CURRENT_TIMESTAMP", "")
                    .replaceAll("( DEFAULT CHARSET).*", "")
                    // 时间替换
                    .replaceAll("datetime DEFAULT NULL", " DateTime ")
                    .replaceAll(" datetime ", " DateTime ");

            /*String规则*/
            // 为空,字符串
            changeRow = changeRow.replaceAll("(` ).*(char).*(DEFAULT NULL)", "` String NULL");
            changeRow = changeRow.replaceAll("(` ).*(char).*(DEFAULT '')", "` String");
            // changeRow = changeRow.replaceAll("(DEFAULT '')", "NULL");
            // 非空,字符串
            changeRow = changeRow.replaceAll("(` ).*(char).*(NOT NULL)", "` String");
            changeRow = changeRow.replaceAll("text", "String");
            changeRow = changeRow.replaceAll("(DEFAULT NULL)", "NULL");
            changeRow = changeRow.replaceAll("(NOT NULL)", "");

            // 以空格分割
            String[] changeColumns = changeRow.split("[ ]");
            //      System.out.println(changeRow);
            // 含有int的替换规则
            if (changeColumns[3].contains("int") || changeColumns[3].contains("bigint")
                    ||changeColumns[3].contains("INT")) {
                changeColumns[3].replaceAll("INT","int");
                changeColumns[3].replaceAll("BIGINT","bigint");
                // 将括号内的数字拿出来
                int length = Integer.parseInt(changeColumns[3]
                        .replaceAll("bigint", "")
                        .replaceAll("tinyint", "")
                        .replaceAll("int", "")
                        .replaceAll("\\(", "")
                        .replaceAll("\\)", ""));
                // 获取数据类型
                String type = changeColumns[3].substring(0, changeColumns[3].indexOf("("));
                // 处理int 是否可以为空值
                String last = " NULL";
                String[] _int = {"Int8", "Int16", "Int32", "Int64"};
                if (changeRow.contains("DEFAULT NULL")) {
                    changeRow = changeRow.replaceAll("DEFAULT NULL", "");
                    for (int j = 0; j < _int.length; j++) {
                        _int[j] = _int[j] + last;
                    }
                }
                if ("tinyint".equals(type)) {
                    changeRow = changeRow
                            .replaceFirst(type + "\\(" + length + "\\)", _int[0]);
                } else if ("smallint".equals(type)) {
                    changeRow = changeRow
                            .replaceFirst(type + "\\(" + length + "\\)", _int[1]);
                } else if ("int".equals(type) || "mediumint".equals(type)) {
                    changeRow = changeRow
                            .replaceFirst(type + "\\(" + length + "\\)", _int[2]);
                } else {
                    changeRow = changeRow
                            .replaceFirst(type + "\\(" + length + "\\)", _int[3]);
                }
            }

            replaceTables.append(changeRow.trim() + "\n");
            if (i == 0) {
                replaceTables.append("\n");
            }
            i++;
        }
        if (replaceTables.toString().contains(",) ENGINE = Memory")) {
            String temp = replaceTables.substring(0, replaceTables.indexOf(",) ENGINE = Memory"));
            replaceTables = new StringBuilder(temp + ") ENGINE = Memory ");
        }
        replaceTables.toString().replaceAll("CREATE TABLE `" + tableName + "`", tableName + "_local");
        if (haveKey) {
            replaceTables.append("PRIMARY KEY " + primaryKey);
        }
        replaceTables.append("\nORDER BY " + primaryKey);
        replaceTables.append(";");
        return replaceTables.toString();
    }
}

mysql建表约束：主键约束、自增约束、外键约束、唯一约束、非空约束、默认约束

1，约束：它够唯一确定一张表中的记录，也就是通过给某个字段添加约束，就是的该字段不重复，且不为空。

Create table user(

Id int primary key,                 约束了主键，不能添加重复

Name varchar(20)

);

在test数据库中创建表，创建表user,插入主键，显示表，其中id的key一栏是PRI证明id是主键

主键是唯一的，不能重复添加，如果还想添加重复的只能改变前面的序号

 主键还有一个条件就是不能为空，目的就是为了重新确认一下记录

2，联合主键——只要联合的主键值加起来不重复就可以，但是都不能为空

3，自增约束和主键约束搭配使用

创建一个表格，直接添加数值前面的id，管控id的值，让它可以自动增长

 4，修改表结构，添加主键

如果创建表的时候，忘记创建主键约束，就是primary key 显示，key那一列为空

Desc是describe的简写

 解决办法，输入alter table 表名 add primary key(id)

5,删除主键

输入alter table 表名 drop primary key;

6,使用modify修改字段，添加约束

7，唯一约束

约束修饰的字段的值不能重复

添加唯一约束,三种方式

（1）alter table user5 add unique(name);

UNI的意思就是name不可以重复

 （2）也可以直接创建唯一约束

 （3）也可以直接写到name后面：name varchar(20)unique

unique写一行的原因是可以添加不止一个元素，如果有多个唯一约束unique(id,name)表示两个键在一起都不重复

（4）通过modeify去添加，添加之前需要先删除

如何去删除唯一约束：alter table user6 drop index name;

通过modify添加：alter table user6 modify name varchar(20) unique;

总结（添加约束）：

1. 建表的时候就添加约束
2. 可以使用alter ...add....
3. 也可以使用alter...modify...
4. 删除使用alter...drop...

8，非空约束——就是修饰的字段不能为空

id在NULL就是YES允许，name在NULL是no不允许

可以让id为空直接赋值lisi就是正确的，但是不能让name为空，不然出现错误

Not null的添加就是让它自己修饰的键不能为空

9，默认约束——当我们插入字段值的时候，如果没有传值，就会使用默认值

 给age默认是10所以她现在是有默认值的为10

现在给id,name插入相应的值，不管age，显示出来age还是默认的值10

 如果给age进行赋值就不会使用原来的值的

10，外键约束

涉及到两个表：父表，子表（主表、副表）

创建一个班级表，和一个学生表，主表是班级表，在给两个表中分别插入信息