Enforce that non-string types can't have collations applied.

Author: rspeele

src/Rezoom.SQL.Compiler/Error.fs

@@ -145,7 +145,10 @@ let tableAlreadyHasPrimaryKey table =
     sprintf "SQ061: ``%O`` already has ``%O`` as its primary key constraint" table
 let cannotDropLastColumn table columnName =
     sprintf "SQ062: ``%O`` can't be dropped because it is the last column remaining in table ``%O``" columnName table
-
+let cannotCollateType typeName =
+    sprintf "SQ063: A column of type ``%O`` cannot have a collation applied" typeName
+let cannotAlterPrimaryKeyColumn columnName =
+    sprintf "SQ064: Cannot alter the column ``%O`` because it is part of the table's primary key" columnName
 
 let tableNameNotSuitableForPG =
     "SQ069: Table name is not suitable for PG (maybe you thought you were writing R?)"

src/Rezoom.SQL.Compiler/ModelOps.fs

@@ -127,6 +127,11 @@ let addTableColumn (tableName : QualifiedObjectName WithSource) (column : Adding
         let! table = getRequiredTable tableName
         match table.Columns |> Map.tryFind column.Name.Value with
         | None ->
+            match column.Collation with
+            | None -> ()
+            | Some _ ->
+                if not column.TypeName.SupportsCollation then
+                    failAt column.Name.Source <| Error.cannotCollateType column.TypeName
             let schemaColumn =
                 {   TableName = tableName.Value
                     ColumnName = column.Name.Value
@@ -423,17 +428,19 @@ let changeColumnType tableName (columnName : Name WithSource) newType =
         | None ->
             failAt columnName.Source <| Error.noSuchColumn columnName.Value
         | Some col ->
+            if col.PrimaryKey then
+                failAt columnName.Source <| Error.cannotAlterPrimaryKeyColumn columnName.Value
             if col.ColumnTypeName = newType then
                 failAt columnName.Source <| Error.columnTypeIsAlready columnName.Value newType
-            else
-                // FUTURE validate that referencing FKs have compatible type? default value has compatible type?
-                let newColumn =
-                    { col with
-                        ColumnType = ColumnType.OfTypeName(newType, col.ColumnType.Nullable)
-                        ColumnTypeName = newType
-                    }
-                let table = { table with Columns = table.Columns |> Map.add columnName.Value newColumn }
-                return! putObject tableName (SchemaTable table)
+            // FUTURE validate that referencing FKs have compatible type? default value has compatible type?
+            let newColumn =
+                { col with
+                    ColumnType = ColumnType.OfTypeName(newType, col.ColumnType.Nullable)
+                    ColumnTypeName = newType
+                    Collation = if newType.SupportsCollation then col.Collation else None
+                }
+            let table = { table with Columns = table.Columns |> Map.add columnName.Value newColumn }
+            return! putObject tableName (SchemaTable table)
     }
 
 let changeColumnNullability tableName (columnName : Name WithSource) newNullable =
@@ -443,13 +450,14 @@ let changeColumnNullability tableName (columnName : Name WithSource) newNullable
         | None ->
             failAt columnName.Source <| Error.noSuchColumn columnName.Value
         | Some col ->
+            if col.PrimaryKey then
+                failAt columnName.Source <| Error.cannotAlterPrimaryKeyColumn columnName.Value
             if col.ColumnType.Nullable = newNullable then
                 failAt columnName.Source <| Error.columnNullabilityIsAlready columnName.Value newNullable
-            else
-                let newColumn =
-                    { col with ColumnType = { col.ColumnType with Nullable = newNullable } }
-                let table = { table with Columns = table.Columns |> Map.add columnName.Value newColumn }
-                return! putObject tableName (SchemaTable table)
+            let newColumn =
+                { col with ColumnType = { col.ColumnType with Nullable = newNullable } }
+            let table = { table with Columns = table.Columns |> Map.add columnName.Value newColumn }
+            return! putObject tableName (SchemaTable table)
     }
 
 let changeColumnCollation tableName (columnName : Name WithSource) newCollation =
@@ -459,11 +467,14 @@ let changeColumnCollation tableName (columnName : Name WithSource) newCollation
         | None ->
             failAt columnName.Source <| Error.noSuchColumn columnName.Value
         | Some col ->
+            if col.PrimaryKey then
+                failAt columnName.Source <| Error.cannotAlterPrimaryKeyColumn columnName.Value
             if col.Collation = Some newCollation then
                 failAt columnName.Source <| Error.columnCollationIsAlready columnName.Value newCollation
-            else
-                let newColumn =
-                    { col with Collation = Some newCollation }
-                let table = { table with Columns = table.Columns |> Map.add columnName.Value newColumn }
-                return! putObject tableName (SchemaTable table)
+            if not col.ColumnTypeName.SupportsCollation then
+                failAt columnName.Source <| Error.cannotCollateType col.ColumnTypeName
+            let newColumn =
+                { col with Collation = Some newCollation }
+            let table = { table with Columns = table.Columns |> Map.add columnName.Value newColumn }
+            return! putObject tableName (SchemaTable table)
     }

src/Rezoom.SQL.Test/TestAlterTable.fs

@@ -83,4 +83,18 @@ let ``can't drop last column`` () =
     { defaultTest with
         Migration = "create table Foo(x int); alter table Foo drop column x"
         Expect = BadMigration <| Error.cannotDropLastColumn "main.Foo" "x"
+    } |> assertSimple
+
+[<Test>]
+let ``can't alter pk column`` () =
+    { defaultTest with
+        Migration = "create table Foo(x int primary key); alter table Foo alter column x int64"
+        Expect = BadMigration <| Error.cannotAlterPrimaryKeyColumn "x"
+    } |> assertSimple
+
+[<Test>]
+let ``can't collate guid`` () =
+    { defaultTest with
+        Migration = "create table Foo(x guid collate foo);"
+        Expect = BadMigration <| Error.cannotCollateType "GUID"
     } |> assertSimple