@@ -61,10 +61,10 @@ module Dialect =
             while i < sql.Length do
                 if sql.[i] = '@' && i + 1 < sql.Length && isNameChar sql.[i + 1] then
                     let start = i + 1
-                    let mutable last = start
+                    let rec advanceLast last =
+                        if last < sql.Length && isNameChar sql.[last] then advanceLast (last + 1) else last
 
-                    while last < sql.Length && isNameChar sql.[last] do
-                        last <- last + 1
+                    let last = advanceLast start
 
                     let name = sql.Substring(start, last - start)
 
 
@@ -49,7 +49,7 @@ let tryOrdinal (rs: ResultSet) (name: string) =
 
 let ordinal (rs: ResultSet) (name: string) =
     match tryOrdinal rs name with
-    | -1 -> failwith ($"No column named '{name}' in result set")
+    | -1 -> failwith $"No column named '{name}' in result set"
     | i -> i
 
 /// Raw value of a named column.
@@ -71,7 +71,7 @@ let private wrongType (name: string) (expected: string) (v: SqlValue) : 'T =
     )
 
 let private nullNotAllowed (name: string) (expected: string) : 'T =
-    failwith ($"Column '{name}' is NULL; use the *Opt reader to allow it ({expected})")
+    failwith $"Column '{name}' is NULL; use the *Opt reader to allow it ({expected})"
 
 // --- int64 --------------------------------------------------------------
 
@@ -153,7 +153,7 @@ let decimalOpt (r: SqlRow) (name: string) : decimal option =
     | SqlText t ->
         match Convert.tryParseDecimal t with
         | Some v -> Some v
-        | None -> failwith ($"Column '{name}': '{t}' is not a decimal")
+        | None -> failwith $"Column '{name}': '{t}' is not a decimal"
     | v -> wrongType name "decimal" v
 
 let decimal (r: SqlRow) (name: string) : decimal =
@@ -169,7 +169,7 @@ let dateTimeOpt (r: SqlRow) (name: string) : System.DateTime option =
     | SqlText t ->
         match Convert.tryParseDate t with
         | Some v -> Some v
-        | None -> failwith ($"Column '{name}': '{t}' is not an ISO-8601 date")
+        | None -> failwith $"Column '{name}': '{t}' is not an ISO-8601 date"
     | v -> wrongType name "date" v
 
 let dateTime (r: SqlRow) (name: string) : System.DateTime =
@@ -185,7 +185,7 @@ let guidOpt (r: SqlRow) (name: string) : System.Guid option =
     | SqlText t ->
         match Convert.tryParseGuid t with
         | Some v -> Some v
-        | None -> failwith ($"Column '{name}': '{t}' is not a GUID")
+        | None -> failwith $"Column '{name}': '{t}' is not a GUID"
     | v -> wrongType name "guid" v
 
 let guid (r: SqlRow) (name: string) : System.Guid =
 
@@ -128,6 +128,14 @@ module SqlGen =
         | [ first; second ] -> first, second
         | _ -> failwith ("SqlGen: " + string fn + " takes exactly two arguments")
 
+    let private renderSource (b: Builder) (s: Source) =
+        let append (t: string) = write b t
+
+        if s.Alias = s.Table then
+            append s.Table
+        else
+            append $"{s.Table} AS {s.Alias}"
+
     /// `.Date`. SQLite and MySQL have DATE(); PostgreSQL's DATE() is not the
     /// same thing, so it uses the truncation SQLProvider uses too.
 
@@ -139,7 +147,7 @@ module SqlGen =
         match e with
         | ColumnRef(table, column) ->
             if b.Qualify then
-                append ($"{table}.{column}")
+                append $"{table}.{column}"
             else
                 append column
 
@@ -500,11 +508,11 @@ module SqlGen =
              | Sqlite ->
                  // STRFTIME returns text, so cast back to a number to keep
                  // comparisons behaving like the other engines.
-                 append ($"CAST(STRFTIME('{strftime}', ")
+                 append $"CAST(STRFTIME('{strftime}', "
                  renderExpr b arg
                  append ") AS INTEGER)"
              | Postgres ->
-                 append ($"EXTRACT({name} FROM ")
+                 append $"EXTRACT({name} FROM "
                  renderExpr b arg
                  append ")"
              | MySql
@@ -587,17 +595,9 @@ module SqlGen =
 
             append "DATETIME("
             renderExpr b inner
-            append ($", '{signed} {unitName}s')")
+            append $", '{signed} {unitName}s')"
 
-    and private renderSource (b: Builder) (s: Source) =
-        let append (t: string) = write b t
-
-        if s.Alias = s.Table then
-            append s.Table
-        else
-            append ($"{s.Table} AS {s.Alias}")
-
-    /// Renders a query into an existing builder, so a subquery shares the outer
+        /// Renders a query into an existing builder, so a subquery shares the outer
     /// statement's parameter list and stays numbered in the order the SQL
     /// mentions it.
     /// One SELECT through its HAVING -- everything that belongs to a single
@@ -763,7 +763,7 @@ module SqlGen =
 
     let renderInsert (vendor: Vendor) (i: Insert) : string * SqlParam[] =
         if i.Assignments.Length = 0 then
-            failwith "SqlGen: the insert sets no columns"
+            failwith $"SqlGen: the insert sets no columns, calling renderInsert with vendor: {vendor}"
 
         // Columns are bare here, not qualified: an INSERT names exactly one
         // table and every engine rejects `INSERT INTO t (t.c) ..`.
@@ -798,10 +798,10 @@ module SqlGen =
     /// would stop the statement being atomic.
     let renderInsertMany (vendor: Vendor) (i: InsertMany) : string * SqlParam[] =
         if i.Columns.Length = 0 then
-            failwith "SqlGen: the insert sets no columns"
+            failwith $"SqlGen: the insert sets no columns, calling renderInsertMany with vendor: {vendor}"
 
         if i.Rows.Length = 0 then
-            failwith "SqlGen: the insert has no rows"
+            failwith $"SqlGen: the insert has no rows, calling renderInsertMany with vendor: {vendor}"
 
         let b = newBuilder vendor false
         write b ($"INSERT INTO {i.Table} (")
@@ -857,10 +857,10 @@ module SqlGen =
 
     let renderUpdate (vendor: Vendor) (u: Update) : string * SqlParam[] =
         if u.Assignments.Length = 0 then
-            failwith "SqlGen: the update sets no columns"
+            failwith $"SqlGen: the update sets no columns, calling renderUpdate with vendor: {vendor}"
 
         if u.Where.IsNone && not u.Unconditional then
-            failwith "SqlGen: the update has no WHERE and would rewrite every row -- say Update.all if that is meant"
+            failwith $"SqlGen: the update has no WHERE and would rewrite every row -- say Update.all if that is meant, calling renderUpdate with vendor: {vendor}"
 
         let b = newBuilder vendor false
         write b ($"UPDATE {u.Table} SET ")
@@ -876,7 +876,7 @@ module SqlGen =
 
     let renderDelete (vendor: Vendor) (d: Delete) : string * SqlParam[] =
         if d.Where.IsNone && not d.Unconditional then
-            failwith "SqlGen: the delete has no WHERE and would empty the table -- say Delete.all if that is meant"
+            failwith $"SqlGen: the delete has no WHERE and would empty the table -- say Delete.all if that is meant, calling renderDelete with vendor: {vendor}"
 
         let b = newBuilder vendor false
         write b ("DELETE FROM " + d.Table)
 
@@ -224,10 +224,10 @@ module Convert =
 
                     // optional ".fffffff"
                     if s.Length > 19 && s.[19] = '.' then
-                        let mutable last = 20
+                        let rec advanceLast last =
+                            if last < s.Length && isDigit s.[last] then advanceLast (last + 1) else last
 
-                        while last < s.Length && isDigit s.[last] do
-                            last <- last + 1
+                        let last = advanceLast 20
 
                         let digits = s.Substring(20, last - 20)
 
 
@@ -131,7 +131,7 @@ module CodeGen =
         line ("/// " + t.Name + (if t.IsView then " (view -- readable, not writable)" else ""))
         line ("module " + identifier t.Name + " =")
         line ""
-        line ($"    let table = \"{t.Name}\"")
+        line $"    let table = \"{t.Name}\""
         line ""
 
         for c in t.Columns do
 
@@ -11,6 +11,7 @@ open Microsoft.Data.Sqlite
 open SQLProvider.Fable
 open SQLProvider.Fable.Ado
 open SQLProvider.Fable.Design
+open System.IO
 
 let private northwindish =
     [ "CREATE TABLE Customer (
@@ -198,10 +199,10 @@ let ``an awkward column name is escaped rather than renamed`` () =
 /// Walks up from the test assembly to the repo root, so the golden file can be
 /// found without hard-coding a path.
 let private repoRoot () =
-    let mutable dir = System.IO.DirectoryInfo(System.AppContext.BaseDirectory)
+    let mutable dir = DirectoryInfo(System.AppContext.BaseDirectory)
 
     while (not (isNull dir))
-          && not (System.IO.File.Exists(System.IO.Path.Combine(dir.FullName, "SQLProvider.Fable.slnx"))) do
+          && not (File.Exists(Path.Combine(dir.FullName, "SQLProvider.Fable.slnx"))) do
         dir <- dir.Parent
 
     if isNull dir then
@@ -210,7 +211,7 @@ let private repoRoot () =
         dir.FullName
 
 let private goldenPath () =
-    System.IO.Path.Combine(repoRoot (), "tests", "SQLProvider.Fable.SmokeTests", "GeneratedSchema.fs")
+    Path.Combine(repoRoot (), "tests", "SQLProvider.Fable.SmokeTests", "GeneratedSchema.fs")
 
 /// Generates from the fixture and compares against the file checked in at
 /// `tests/SQLProvider.Fable.SmokeTests/GeneratedSchema.fs`.
@@ -233,11 +234,11 @@ let ``the generated file is up to date`` () =
             let path = goldenPath ()
 
             if System.Environment.GetEnvironmentVariable "SQLPROVIDER_FABLE_REGENERATE" = "1" then
-                System.IO.File.WriteAllText(path, source)
+                File.WriteAllText(path, source)
 
             let existing =
-                if System.IO.File.Exists path then
-                    System.IO.File.ReadAllText(path).Replace("\r\n", "\n")
+                if File.Exists path then
+                    File.ReadAllText(path).Replace("\r\n", "\n")
                 else
                     ""
 
 
@@ -5,6 +5,7 @@ open Microsoft.Data.Sqlite
 open SQLProvider.Fable
 open SQLProvider.Fable.Ado
 open SQLProvider.Fable.SmokeTests
+open System.Globalization
 
 let private assertAllPassed (results: Harness.TestResult[]) =
     let failures =
@@ -64,10 +65,10 @@ let ``shared smoke suite passes with numbered placeholders`` () =
 /// conversion, this fails and the en-GB run above would not have noticed.
 [<Fact>]
 let ``shared smoke suite passes under a comma-separator locale`` () =
-    let original = System.Globalization.CultureInfo.CurrentCulture
+    let original = CultureInfo.CurrentCulture
 
     try
-        System.Globalization.CultureInfo.CurrentCulture <- System.Globalization.CultureInfo "fi-FI"
+        CultureInfo.CurrentCulture <- CultureInfo "fi-FI"
 
         use connection = new SqliteConnection("Data Source=:memory:")
         connection.Open()
@@ -78,18 +79,18 @@ let ``shared smoke suite passes under a comma-separator locale`` () =
         |> Async.RunSynchronously
         |> assertAllPassed
     finally
-        System.Globalization.CultureInfo.CurrentCulture <- original
+        CultureInfo.CurrentCulture <- original
 
 /// Column lookup must not depend on the locale either. Turkish lowers 'I' to a
 /// dotless 'ı', so a culture-sensitive fold stops "CustomerId" matching the
 /// "customerid" PostgreSQL hands back for an unquoted column -- which is the
 /// everyday case, not an exotic one, for anyone running under tr-TR.
 [<Fact>]
 let ``column lookup is case-insensitive under the Turkish locale`` () =
-    let original = System.Globalization.CultureInfo.CurrentCulture
+    let original = CultureInfo.CurrentCulture
 
     try
-        System.Globalization.CultureInfo.CurrentCulture <- System.Globalization.CultureInfo "tr-TR"
+        CultureInfo.CurrentCulture <- CultureInfo "tr-TR"
 
         let rs =
             { Columns = [| "customerid" |]
@@ -101,4 +102,4 @@ let ``column lookup is case-insensitive under the Turkish locale`` () =
         | None -> failwith "the result set has a row"
         | Some row -> Assert.Equal(42L, Row.int64 row "CustomerId")
     finally
-        System.Globalization.CultureInfo.CurrentCulture <- original
+        CultureInfo.CurrentCulture <- original
@@ -46,6 +46,7 @@ module Order =
     let OrderId = Col.int64 table "OrderId"
     let CustomerId = Col.int64 table "CustomerId"
 
+    [<Struct>]
     type Row = { OrderId: int64 }
 
     let qualified = [| "Orders_OrderId", OrderId.E |]