Improve SQL parser for SQL Server specific syntax

frontend/src/DataSources/SqlMiner/Parsers/CreateTable.elm

@@ -61,7 +61,7 @@ type alias ParsedCheck =
 parseCreateTable : SqlStatement -> Result (List ParseError) ParsedTable
 parseCreateTable statement =
     -- TODO: handle https://www.postgresql.org/docs/current/ddl-inherit.html
-    case statement |> buildSqlLine |> Regex.matches "^CREATE(?:\\s+(?:UNLOGGED|FOREIGN))? TABLE(?:\\s+IF NOT EXISTS)?\\s+(?:(?<db>[^ .]+)\\.)?(?:(?<schema>[^ .]+)\\.)?(?<table>[^ .]+)\\s*(?<rest>\\(.+\\).*);$" of
+    case statement |> buildSqlLine |> Regex.matches "^CREATE(?:\\s+(?:UNLOGGED|FOREIGN))? TABLE(?:\\s+IF NOT EXISTS)?\\s+(?:(?<db>[^ .]+)\\.)?(?:(?<schema>[^ .]+)\\.)?(?<table>[^ .]+)\\s*(?<rest>\\(.+\\).*);?$" of
         db :: schema :: (Just table) :: (Just rest) :: [] ->
             let
                 schemaName : Maybe SqlSchemaName
@@ -128,7 +128,7 @@ extractBody rest =
 
 parseCreateTableColumn : RawSql -> Result ParseError ParsedColumn
 parseCreateTableColumn sql =
-    case sql |> Regex.matches "^(?<name>[^ ]+)\\s+(?<type>.*?)(?:\\s+COLLATE [^ ]+)?(?:\\s+DEFAULT\\s+(?<default1>.*?))?( PRIMARY KEY)?(?<nullable>\\s+NOT NULL)?(?:\\s+COLLATE [^ ]+)?(?:\\s+DEFAULT\\s+(?<default2>.*?))?(?:\\s+CONSTRAINT\\s+(?<constraint>.*))?(?:\\s+(?<reference>REFERENCES\\s+.*?))?(?<nullable2>\\s+NOT NULL)?(?: AUTO_INCREMENT)?( PRIMARY KEY)?( UNIQUE)?(?: CHECK ?\\((?<check>.*?)\\))?( GENERATED .*?)?(?:\\s+COMMENT '(?<comment>(?:[^']|'')+)')?(?:\\s+COMMENT \"(?<comment2>(?:[^\"]|\"\")+)\")?$" of
+    case sql |> Regex.matches "^(?<name>[^ ]+)\\s+(?<type>.*?)(?:\\s+COLLATE [^ ]+)?(?:\\s+DEFAULT\\s+(?<default1>.*?))?( PRIMARY KEY)?(?<nullable>\\s+NOT NULL)?(?:\\s+NULL)?(?:\\s+COLLATE [^ ]+)?(?:\\s+DEFAULT\\s+(?<default2>.*?))?(?:\\s+CONSTRAINT\\s+(?<constraint>.*))?(?:\\s+(?<reference>REFERENCES\\s+.*?))?(?<nullable2>\\s+NOT NULL)?(?: AUTO_INCREMENT)?( PRIMARY KEY)?( UNIQUE)?(?: CHECK ?\\((?<check>.*?)\\))?( GENERATED .*?)?(?:\\s+COMMENT '(?<comment>(?:[^']|'')+)')?(?:\\s+COMMENT \"(?<comment2>(?:[^\"]|\"\")+)\")?$" of
         (Just name) :: (Just kind) :: default1 :: maybePrimary :: nullable :: default2 :: maybeConstraints :: maybeReference :: nullable2 :: maybePrimary2 :: maybeUnique :: maybeCheck :: maybeGenerated :: maybeComment :: maybeComment2 :: [] ->
             maybeConstraints
                 |> Maybe.mapOrElse (Regex.split (Regex.asRegexI " *constraint *")) []

frontend/tests/DataSources/SqlMiner/Parsers/CreateTableTest.elm

@@ -56,6 +56,16 @@ suite =
             , testStatement ( parseCreateTable, "with multiple constraints" )
                 "CREATE TABLE t1 (id int constraint t1_pk primary key constraint t1_t2_fk references t2);"
                 { parsedTable | schema = Nothing, table = "t1", columns = Nel { parsedColumn | name = "id", kind = "int", primaryKey = Just "t1_pk", foreignKey = Just ( Just "t1_t2_fk", { schema = Nothing, table = "t2", column = Nothing } ) } [] }
+            , testStatement ( parseCreateTable, "sql server escaped types" )
+                "CREATE TABLE [dbo].[table1]( [Id] [bigint] IDENTITY(1,1) NOT NULL, [Name] [varchar](20) NULL) ON [PRIMARY]"
+                { parsedTable
+                    | schema = Just "dbo"
+                    , table = "table1"
+                    , columns =
+                        Nel { parsedColumn | name = "Id", kind = "bigint", nullable = False, primaryKey = Just "" }
+                            [ { parsedColumn | name = "Name", kind = "varchar(20)" }
+                            ]
+                }
             ]
         , describe "parseCreateTableColumn"
             [ testSql ( parseCreateTableColumn, "basic" )

libs/utils/src/object.ts

@@ -2,10 +2,18 @@ export function mapValues<T, U>(obj: Record<string, T>, f: (t: T) => U): Record<
     return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, f(v)]))
 }
 
-export function filterValues<T>(obj: Record<string, T>, p: (t: T) => boolean): Record<string, T> {
+export function filterKeys<T>(obj: Record<string, T>, p: (k: string) => boolean): Record<string, T> {
+    return Object.fromEntries(Object.entries(obj).filter(([k]) => p(k)))
+}
+
+export function filterValues<T>(obj: Record<string, T>, p: (v: T) => boolean): Record<string, T> {
     return Object.fromEntries(Object.entries(obj).filter(([, v]) => p(v)))
 }
 
+export function omit<T>(obj: { [key: string]: T }, keys: string[]): { [key: string]: T } {
+    return filterKeys(obj, key => !keys.includes(key))
+}
+
 export function removeUndefined<K extends keyof any, V, T extends Record<K, V>>(obj: T): T {
     return filterValues(obj, v => v !== undefined) as T
 }