Merge pull request #47 from smoothdeveloper/better-error-message-table-name-qualified-with-schema

better exception message when sql contains qualified table name

Author: rspeele

src/Rezoom.SQL.Compiler/Error.fs

@@ -43,8 +43,11 @@ let columnAlreadyExists name =
     sprintf "SQ018: Column ``%O`` already exists" name
 let noSuchColumnToSet tbl col =
     sprintf "SQ019: No such column in table ``%O`` to set: ``%O``" tbl col
-let noSuchSchema schema =
-    sprintf "SQ020: No such schema: ``%O``" schema
+let noSuchSchema existingSchemas schema =
+    sprintf 
+      "SQ020: No such schema: ``%O``, existing schemas: %s." 
+        schema
+        (existingSchemas |> Map.toArray |> Array.map (fst >> sprintf "``%O``") |> String.concat ", ")
 let ambiguousColumn name =
     sprintf "SQ021: Ambiguous column: ``%O``" name
 let ambiguousColumnBetween name tbl1 tbl2 =

src/Rezoom.SQL.Compiler/InferredTypes.fs

@@ -290,8 +290,8 @@ and [<NoComparison>]
                 | None ->
                     let schema = this.Model.Schemas.[this.Model.DefaultSchema]
                     this.ResolveObjectReferenceBySchema(schema, name.ObjectName, inferView)
-        | Some schema ->
-            let schema = this.Model.Schemas.[schema]
+        | Some schemaName ->
+            let schema = { Source = name.Source; Value = Some schemaName } |> ModelOps.getRequiredSchema |> State.runForOuputValue this.Model
             this.ResolveObjectReferenceBySchema(schema, name.ObjectName, inferView)
 
     /// Resolve a column reference, which may be qualified with a table alias.

src/Rezoom.SQL.Compiler/ModelOps.fs

@@ -27,16 +27,32 @@ let private requireNoObject (name : QualifiedObjectName WithSource) =
         | None -> ()
     }
 
+let getRequiredSchema (schemaName: Name option WithSource) =
+    stateful {
+        let! model = State.get
+        let source = schemaName.Source
+        let schemaName =
+            match schemaName.Value with
+            | None -> model.DefaultSchema
+            | Some name -> name
+        let! schema = getSchema schemaName
+        return
+            match schema with
+            | Some obj -> obj
+            | None ->
+                schemaName
+                |> Error.noSuchSchema model.Schemas
+                |> failAt source
+    }
+
 let getRequiredObject objectTypeName (name : QualifiedObjectName WithSource) =
     stateful {
-        let! schema = getSchema name.Value.SchemaName
-        match schema with
-        | None -> return failAt name.Source <| Error.noSuchSchema name.Value.SchemaName
-        | Some schema ->
-            return
-                match schema.Objects |> Map.tryFind name.Value.ObjectName with
-                | None -> failAt name.Source <| Error.noSuchObject objectTypeName name.Value.ObjectName
-                | Some obj -> obj
+        let! model = State.get
+        let! schema = name.Map(fun n -> Some n.SchemaName) |> getRequiredSchema
+        return
+            match schema.Objects |> Map.tryFind name.Value.ObjectName with
+            | None -> failAt name.Source <| Error.noSuchObject objectTypeName name.Value.ObjectName
+            | Some obj -> obj
     }
 
 let getRequiredTable name =
@@ -75,27 +91,19 @@ let putSchema (schema : Schema) =
 /// Create or update an object within an existing schema in the model.
 let putObject (name : QualifiedObjectName WithSource) (obj : SchemaObject) =
     stateful {
-        let! schema = getSchema name.Value.SchemaName
-        match schema with
-        // shouldn't have called this with a bogus schema
-        | None ->
-            failAt name.Source <| Error.noSuchSchema name.Value.SchemaName
-        | Some schema ->
-            let newSchema = { schema with Objects = schema.Objects |> Map.add name.Value.ObjectName obj }
-            return! putSchema newSchema
+        let! model = State.get
+        let! schema = name.Map(fun n -> Some n.SchemaName) |> getRequiredSchema
+        let newSchema = { schema with Objects = schema.Objects |> Map.add name.Value.ObjectName obj }
+        return! putSchema newSchema
     }
 
 /// Remove an existing object from the model.
 let removeObject (name : QualifiedObjectName WithSource) =
     stateful {
-        let! schema = getSchema name.Value.SchemaName
-        match schema with
-        // shouldn't have called this with a bogus schema
-        | None ->
-            failAt name.Source <| Error.noSuchSchema name.Value.SchemaName
-        | Some schema ->
-            let newSchema = { schema with Objects = schema.Objects |> Map.remove name.Value.ObjectName }
-            return! putSchema newSchema
+        let! model = State.get
+        let! schema = name.Map(fun n -> Some n.SchemaName) |> getRequiredSchema
+        let newSchema = { schema with Objects = schema.Objects |> Map.remove name.Value.ObjectName }
+        return! putSchema newSchema
     }
 
 /// Create a new table with a given name.
@@ -477,4 +485,4 @@ let changeColumnCollation tableName (columnName : Name WithSource) newCollation
                 { 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/Environment.fs

@@ -19,15 +19,17 @@ let userModel1() = userModelByName "user-model-1"
 
 let userModel2() = userModelByName "user-model-2"
 
-let expectError (msg : string) (sql : string) =
+let expectErrorWithModel (mkMsg : Model -> string) (sql : string) =
     let userModel = userModel1()
     try
         ignore <| CommandEffect.OfSQL(userModel.Model, "anonymous", sql)
         failwith "Should've thrown an exception!"
     with
     | :? SourceException as exn ->
         printfn "\"%s\"" exn.Message
-        Assert.AreEqual(msg, exn.Reason.Trim())
+        Assert.AreEqual(mkMsg userModel.Model, exn.Reason.Trim())
+
+let expectError (msg : string) (sql : string) = expectErrorWithModel (fun _ -> msg) sql
 
 let dispenserParameterIndexer() =
     let dict = Dictionary()

src/Rezoom.SQL.Test/TestModelErrors.fs

@@ -45,4 +45,9 @@ let ``no such column to index on creation`` () =
 [<Test>]
 let ``can't drop table referenced by others`` () =
     expectError (Error.tableIsReferencedByFKs "main.Users" ["main.UserGroupMaps"])
-        "drop table Users"
+        "drop table Users"
+
+[<Test>]
+let ``non existing schema name`` () =
+    expectErrorWithModel (fun model -> Error.noSuchSchema model.Schemas "a")
+        "select * from a.b"