Change .ToUpper() to .ToUpperInvariant() for culture-independent string comparisons

Co-authored-by: Thorium <229355+Thorium@users.noreply.github.com>

Author: Copilot

src/SQLProvider.Common/SqlRuntime.Common.fs

@@ -1100,7 +1100,7 @@ module public OfflineTools =
                             match dummydata.TryGetValue(arg1.ToLower()) with
                             | true, tableData -> createMockEntitiesDc this arg1 tableData
                             | false, _ ->
-                                match dummydata |> Map.toSeq |> Seq.tryFind(fun (k,v) -> k.ToUpper() = arg1.ToUpper()) with
+                                match dummydata |> Map.toSeq |> Seq.tryFind(fun (k,v) -> k.ToUpperInvariant() = arg1.ToUpperInvariant()) with
                                 | Some (k, tableData) -> createMockEntitiesDc this arg1 tableData
                                 | None -> failwith ("Add table to dummydata: " + arg1) 
                     member this.CreateEntity(arg1: string): SqlEntity =

src/SQLProvider.Common/Ssdt.DacpacParser.fs

@@ -260,11 +260,11 @@ let parseXml(xml: string) =
             let annotation = RegexParsers.parseTableColumnAnnotation colName colExpr
             let dataType =
                 annotation
-                |> ValueOption.map (fun a -> a.DataType.ToUpper()) // Ucase to match typeMappings
+                |> ValueOption.map (fun a -> a.DataType.ToUpperInvariant()) // Ucase to match typeMappings
                 |> ValueOption.defaultValue "SQL_VARIANT"
             let allowNulls =
                 match annotation with
-                | ValueSome { Nullability = ValueSome nlb } -> nlb.ToUpper() = "NULL"
+                | ValueSome { Nullability = ValueSome nlb } -> nlb.ToUpperInvariant() = "NULL"
                 | ValueSome { Nullability = ValueNone } -> true // Sql Server column declarations allow nulls by default
                 | ValueNone -> false // Default to "SQL_VARIANT" (obj) with no nulls if annotation is not found
 
@@ -411,7 +411,7 @@ let parseXml(xml: string) =
 
     let parseUserDefinedDataType (uddts: XmlNode) =
         let name = uddts |> att "Name"
-        let name = name |> RegexParsers.splitFullName |> fun parsed -> (String.concat "." parsed).ToUpper() |> UDDTName
+        let name = name |> RegexParsers.splitFullName |> fun parsed -> (String.concat "." parsed).ToUpperInvariant() |> UDDTName
         let inheritedType =
             uddts
             |> nodes "x:Relationship"
@@ -420,7 +420,7 @@ let parseXml(xml: string) =
             |> att "Name"
             |> RegexParsers.splitFullName
             |> fun parsed -> String.concat "." parsed
-            |> fun t -> t.ToUpper()
+            |> fun t -> t.ToUpperInvariant()
             |> UDDTInheritedType
         (name, inheritedType)
 
@@ -490,11 +490,11 @@ let parseXml(xml: string) =
                     // Can't resolve column, or annotation override: try to find a commented type annotation
                     let dataType =
                         annotation
-                        |> Option.map (fun a -> a.DataType.ToUpper()) // Ucase to match typeMappings
+                        |> Option.map (fun a -> a.DataType.ToUpperInvariant()) // Ucase to match typeMappings
                         |> Option.defaultValue "SQL_VARIANT"
                     let allowNulls =
                         match annotation with
-                        | Some { Nullability = ValueSome nlb } -> nlb.ToUpper() = "NULL"
+                        | Some { Nullability = ValueSome nlb } -> nlb.ToUpperInvariant() = "NULL"
                         | Some { Nullability = ValueNone } -> true // Sql Server column declarations allow nulls by default
                         | None -> false // Default to "SQL_VARIANT" (obj) with no nulls if annotation is not found
                     let description =

src/SQLProvider.Common/Utils.fs

@@ -270,7 +270,7 @@ module Utilities =
         let prefix2 = alias + "."
         let prefix3 = "`" + alias + "`."
         let prefix4 = alias + "_"
-        let prefix5 = alias.ToUpper() + "_"
+        let prefix5 = alias.ToUpperInvariant() + "_"
         let prefix6 = "\"" + alias + "\"."
         (fun (k:string,v) ->
             if k.StartsWith prefix then

src/SQLProvider.DesignTime/SqlDesignTime.fs

@@ -554,7 +554,7 @@ module DesignTimeUtils =
             let caseInsensitivityCheck =
                 match caseSensitivity with
                 | CaseSensitivityChange.TOLOWER -> (fun (x:string) -> x.ToLower())
-                | CaseSensitivityChange.TOUPPER -> (fun (x:string) -> x.ToUpper())
+                | CaseSensitivityChange.TOUPPER -> (fun (x:string) -> x.ToUpperInvariant())
                 | _ -> id
 
             let conString = ConfigHelpers.tryGetConnectionString false config.ResolutionFolder conStringName connectionString

src/SQLProvider.Runtime/Providers.DuckDb.fs

@@ -202,7 +202,7 @@ module DuckDb =
 
         let dbMappings =
             mappings
-            |> List.map (fun m -> (match m.ProviderTypeName with ValueSome x -> x | ValueNone -> "").ToUpper(), m)
+            |> List.map (fun m -> (match m.ProviderTypeName with ValueSome x -> x | ValueNone -> "").ToUpperInvariant(), m)
             |> Map.ofList
 
         typeMappings <- mappings
@@ -589,7 +589,7 @@ type internal DuckDbProvider(resolutionPath, contextSchemaPath, owner:string, re
                         let maxlen =
                             if reader.IsDBNull(2) then ""
                             else reader.GetValue(2).ToString()
-                        let isUnsigned = not(reader.IsDBNull 6) && reader.GetString(6).ToUpper().Contains("UNSIGNED")
+                        let isUnsigned = not(reader.IsDBNull 6) && reader.GetString(6).ToUpperInvariant().Contains("UNSIGNED")
                         let udt = if isUnsigned then dt + " unsigned" else dt
                         match DuckDb.findDbType udt with
                         | Some(m) ->

src/SQLProvider.Runtime/Providers.MsSqlServer.Dynamic.fs

@@ -331,7 +331,7 @@ module MSSqlServerDynamic =
             not <| Set.contains name toFilter)
         |> DataTable.map (fun row -> getSprocName row, dbUnbox<string> row.["routine_type"])
         |> Seq.map (fun (name, routineType) ->
-             match routineType.ToUpper() with
+             match routineType.ToUpperInvariant() with
              | "FUNCTION" -> Root("Functions",  Sproc({ Name = name; Params = (fun con -> getSprocParameters con name); ReturnColumns = (fun con sparams -> getSprocReturnCols con name sparams) }))
              | "PROCEDURE" ->  Root("Procedures", Sproc({ Name = name; Params = (fun con -> getSprocParameters con name); ReturnColumns = (fun con sparams -> getSprocReturnCols con name sparams) }))
              | _ -> Empty

src/SQLProvider.Runtime/Providers.MsSqlServer.Ssdt.fs

@@ -160,10 +160,10 @@ module MSSqlServerSsdt =
         |> Map.ofList
 
     let tryFindMapping (dataType: string) =
-        typeMappingsByName.TryFind (dataType.ToUpper())
+        typeMappingsByName.TryFind (dataType.ToUpperInvariant())
 
     let rec tryFindMappingOrVariant (uddts: SsdtUserDefinedDataType) (dataType: string) =
-        let dataType = dataType.ToUpper()
+        let dataType = dataType.ToUpperInvariant()
         match typeMappingsByName.TryFind dataType with
         | Some tm -> tm
         | None ->

src/SQLProvider.Runtime/Providers.MsSqlServer.fs

@@ -258,7 +258,7 @@ module MSSqlServer =
             not <| Set.contains name toFilter)
         |> DataTable.map (fun row -> getSprocName row, dbUnbox<string> row.["routine_type"])
         |> Seq.map (fun (name, routineType) ->
-             match routineType.ToUpper() with
+             match routineType.ToUpperInvariant() with
              | "FUNCTION" -> Root("Functions",  Sproc({ Name = name; Params = (fun con -> getSprocParameters con name); ReturnColumns = (fun con sparams -> getSprocReturnCols con name sparams) }))
              | "PROCEDURE" ->  Root("Procedures", Sproc({ Name = name; Params = (fun con -> getSprocParameters con name); ReturnColumns = (fun con sparams -> getSprocReturnCols con name sparams) }))
              | _ -> Empty

src/SQLProvider.Runtime/Providers.MySql.fs

@@ -302,7 +302,7 @@ module MySql =
         getSchema "Procedures" [||] con
         |> DataTable.map (fun row ->
                             let name = getSprocName row
-                            match (Sql.dbUnbox<string> row.["routine_type"]).ToUpper() with
+                            match (Sql.dbUnbox<string> row.["routine_type"]).ToUpperInvariant() with
                             | "FUNCTION" -> Root("Functions", Sproc({ Name = name; Params = (fun con -> getSprocParameters con name); ReturnColumns = (fun _ name -> getSprocReturnCols name) }))
                             | "PROCEDURE" ->  Root("Procedures", Sproc({ Name = name; Params = (fun con -> getSprocParameters con name); ReturnColumns = (fun _ name -> getSprocReturnCols name) }))
                             | _ -> Empty
@@ -633,7 +633,7 @@ type internal MySqlProvider(resolutionPath, contextSchemaPath, owner:string, ref
                         let maxlen =
                             if reader.IsDBNull(2) then ""
                             else reader.GetValue(2).ToString()
-                        let isUnsigned = not(reader.IsDBNull 6) && reader.GetString(6).ToUpper().Contains("UNSIGNED")
+                        let isUnsigned = not(reader.IsDBNull 6) && reader.GetString(6).ToUpperInvariant().Contains("UNSIGNED")
                         let udt = if isUnsigned then dt + " unsigned" else dt
                         match MySql.findDbType udt with
                         | Some(m) ->