update

Author: aleksei.p

tests/sqlparser_clickhouse.rs

@@ -220,6 +220,68 @@ fn parse_create_table() {
     );
 }
 
+fn column_def(name: Ident, data_type: DataType) -> ColumnDef {
+    ColumnDef {
+        name,
+        data_type,
+        collation: None,
+        options: vec![],
+    }
+}
+
+#[test]
+fn parse_clickhouse_data_types() {
+    let sql = concat!(
+        "CREATE TABLE table (",
+        "a1 UInt8, a2 UInt16, a3 UInt32, a4 UInt64, a5 UInt128, a6 UInt256,",
+        " b1 Int8, b2 Int16, b3 Int32, b4 Int64, b5 Int128, b6 Int256,",
+        " c1 Float32, c2 Float64,",
+        " d1 Date32, d2 DateTime64(3), d3 DateTime64(3, 'UTC'),",
+        " e1 FixedString(255),",
+        " f1 LowCardinality(Int32)",
+        ") ORDER BY (a1)",
+    );
+    // ClickHouse has a case-sensitive definition of data type, but canonical representation is not
+    let canonical_sql = sql
+        .replace(" Int8", " INT8")
+        .replace(" Int64", " INT64")
+        .replace(" Float64", " FLOAT64");
+
+    match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) {
+        Statement::CreateTable { name, columns, .. } => {
+            assert_eq!(name, ObjectName(vec!["table".into()]));
+            assert_eq!(
+                columns,
+                vec![
+                    column_def("a1".into(), DataType::UInt8),
+                    column_def("a2".into(), DataType::UInt16),
+                    column_def("a3".into(), DataType::UInt32),
+                    column_def("a4".into(), DataType::UInt64),
+                    column_def("a5".into(), DataType::UInt128),
+                    column_def("a6".into(), DataType::UInt256),
+                    column_def("b1".into(), DataType::Int8(None)),
+                    column_def("b2".into(), DataType::Int16),
+                    column_def("b3".into(), DataType::Int32),
+                    column_def("b4".into(), DataType::Int64),
+                    column_def("b5".into(), DataType::Int128),
+                    column_def("b6".into(), DataType::Int256),
+                    column_def("c1".into(), DataType::Float32),
+                    column_def("c2".into(), DataType::Float64),
+                    column_def("d1".into(), DataType::Date32),
+                    column_def("d2".into(), DataType::Datetime64(3, None)),
+                    column_def("d3".into(), DataType::Datetime64(3, Some("UTC".into()))),
+                    column_def("e1".into(), DataType::FixedString(255)),
+                    column_def(
+                        "f1".into(),
+                        DataType::LowCardinality(Box::new(DataType::Int32))
+                    ),
+                ]
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_create_table_with_nullable() {
     let sql = r#"CREATE TABLE table (k UInt8, `a` Nullable(String), `b` Nullable(DateTime64(9, 'UTC')), c Nullable(DateTime64(9)), d Date32 NULL) ENGINE=MergeTree ORDER BY (`k`)"#;
@@ -232,42 +294,23 @@ fn parse_create_table_with_nullable() {
             assert_eq!(
                 columns,
                 vec![
-                    ColumnDef {
-                        name: Ident::new("k"),
-                        data_type: DataType::UInt8,
-                        collation: None,
-                        options: vec![],
-                    },
-                    ColumnDef {
-                        name: Ident::with_quote('`', "a"),
-                        data_type: DataType::Nullable(Box::new(DataType::String(None))),
-                        collation: None,
-                        options: vec![],
-                    },
-                    ColumnDef {
-                        name: Ident::with_quote('`', "b"),
-                        data_type: DataType::Nullable(Box::new(DataType::Datetime64(
+                    column_def("k".into(), DataType::UInt8),
+                    column_def(
+                        Ident::with_quote('`', "a"),
+                        DataType::Nullable(Box::new(DataType::String(None)))
+                    ),
+                    column_def(
+                        Ident::with_quote('`', "b"),
+                        DataType::Nullable(Box::new(DataType::Datetime64(
                             9,
                             Some("UTC".to_string())
-                        ))),
-                        collation: None,
-                        options: vec![],
-                    },
-                    ColumnDef {
-                        name: Ident::new("c"),
-                        data_type: DataType::Nullable(Box::new(DataType::Datetime64(9, None))),
-                        collation: None,
-                        options: vec![],
-                    },
-                    ColumnDef {
-                        name: Ident::new("d"),
-                        data_type: DataType::Date32,
-                        collation: None,
-                        options: vec![ColumnOptionDef {
-                            name: None,
-                            option: ColumnOption::Null
-                        }],
-                    },
+                        )))
+                    ),
+                    column_def(
+                        "c".into(),
+                        DataType::Nullable(Box::new(DataType::Datetime64(9, None)))
+                    ),
+                    column_def("d".into(), DataType::Date32),
                 ]
             );
         }
@@ -295,22 +338,16 @@ fn parse_create_table_with_nested_data_types() {
                     ColumnDef {
                         name: Ident::new("i"),
                         data_type: DataType::Nested(vec![
-                            ColumnDef {
-                                name: "a".into(),
-                                data_type: DataType::Array(ArrayElemTypeDef::Parenthesis(
-                                    Box::new(DataType::Int16),
-                                )),
-                                collation: None,
-                                options: vec![],
-                            },
-                            ColumnDef {
-                                name: "b".into(),
-                                data_type: DataType::LowCardinality(Box::new(DataType::String(
-                                    None
-                                ))),
-                                collation: None,
-                                options: vec![],
-                            },
+                            column_def(
+                                "a".into(),
+                                DataType::Array(ArrayElemTypeDef::Parenthesis(Box::new(
+                                    DataType::Int16
+                                ),))
+                            ),
+                            column_def(
+                                "b".into(),
+                                DataType::LowCardinality(Box::new(DataType::String(None)))
+                            )
                         ]),
                         collation: None,
                         options: vec![],