* ValueNone via reflection is simplified

* Added tests

Author: QrystaL

src/SQLProvider.Common/SqlRuntime.Common.fs

@@ -14,6 +14,7 @@ open FSharp.Data.Sql.Transactions
 open FSharp.Data.Sql.Schema
 open Microsoft.FSharp.Reflection
 open System.Collections.Concurrent
+open System.Runtime.Serialization
 
 type DatabaseProviderTypes =
     | MSSQLSERVER = 0
@@ -361,9 +362,8 @@ type SqlEntity(dc: ISqlDataContext, tableName, columns: ColumnLookup, activeColu
                 [|
                     for prop in fields do
                         match dataMap.TryGetValue(clean prop) with
-                        | true, null when (prop.PropertyType.Name.StartsWith "FSharpValueOption" || prop.PropertyType.Name.StartsWith "FSharpOption") ->
-                            let cases = FSharpType.GetUnionCases prop.PropertyType
-                            let typedNone = FSharpValue.MakeUnion(cases[0], null)
+                        | true, null when prop.PropertyType.Name.StartsWith "FSharpValueOption" ->
+                            let typedNone = FormatterServices.GetUninitializedObject prop.PropertyType
                             yield propertyTypeMapping (prop.Name, typedNone)
                         | true, dataVal -> yield propertyTypeMapping (prop.Name, (Utilities.convertTypes dataVal prop.PropertyType))
                         | false, _ -> ()
@@ -373,9 +373,8 @@ type SqlEntity(dc: ISqlDataContext, tableName, columns: ColumnLookup, activeColu
             let instance = Activator.CreateInstance<'a>()
             for prop in typ.GetProperties() do
                 match dataMap.TryGetValue(clean prop) with
-                | true, null when (prop.PropertyType.Name.StartsWith "FSharpValueOption" || prop.PropertyType.Name.StartsWith "FSharpOption") ->
-                    let cases = FSharpType.GetUnionCases prop.PropertyType
-                    let typedNone = FSharpValue.MakeUnion(cases[0], null)
+                | true, null when prop.PropertyType.Name.StartsWith "FSharpValueOption" ->
+                    let typedNone = FormatterServices.GetUninitializedObject prop.PropertyType
                     prop.GetSetMethod().Invoke(instance, [|propertyTypeMapping (prop.Name, typedNone)|]) |> ignore
                 | true, dataVal -> prop.GetSetMethod().Invoke(instance, [|propertyTypeMapping (prop.Name, (Utilities.convertTypes dataVal prop.PropertyType))|]) |> ignore
                 | false, _ -> ()

tests/SqlProvider.Tests/QueryTests.fs

@@ -2931,26 +2931,48 @@ let ``mock for unit-testing: datacontext``() =
 
 
 // Generated with dc.Main.OrderDetails.TemplateAsRecord
-type MyMainOrders = { CustomerId : String voption; EmployeeId : Int64 voption; Freight : Decimal voption; OrderDate : DateTime voption; OrderId : Int64; RequiredDate : DateTime voption; ShipAddress : String voption; ShipCity : String voption; ShipCountry : String voption; ShipName : String voption; ShipPostalCode : String voption; ShipRegion : String voption; ShippedDate : DateTime voption }
-
-type MyMainOrders2() =
-    class
-        member val CustomerId = ValueSome "" with get,set
-        member val ShipRegion = ValueSome "" with get,set
-    end
+type OrderDetailsRecordVopts = { CustomerId : String voption; EmployeeId : Int64 voption; Freight : Decimal voption; OrderDate : DateTime voption; OrderId : Int64; RequiredDate : DateTime voption; ShipAddress : String voption; ShipCity : String voption; ShipCountry : String voption; ShipName : String voption; ShipPostalCode : String voption; ShipRegion : String voption; ShippedDate : DateTime voption }
 
+type OrderDetailsClassVopts() =
+    member val CustomerId = ValueSome "" with get, set
+    member val ShipRegion = ValueSome "" with get, set
 
 [<Test >]
-let ``simple select query with MapTo``() = 
+let ``simple select query with MapTo with voptions``() = 
     let dc = sqlValueOption.GetDataContext()
 
     let qry = 
         query {
             for ord in dc.Main.Orders do
             select (ord)
         } |> Seq.head
-    let mapped1 = qry.MapTo<MyMainOrders>()
-    let mapped2 = qry.MapTo<MyMainOrders2>()
+    let mapped1 = qry.MapTo<OrderDetailsRecordVopts>()
+    let mapped2 = qry.MapTo<OrderDetailsClassVopts>()
 
     Assert.AreEqual(ValueSome "VINET", mapped1.CustomerId)
+    Assert.True(mapped1.ShipRegion.IsNone)
     Assert.AreEqual(ValueSome "VINET", mapped2.CustomerId)
+    Assert.True(mapped2.ShipRegion.IsNone)
+
+type OrderDetailsRecordOpts = { CustomerId : String option; EmployeeId : Int64 option; Freight : Decimal option; OrderDate : DateTime option; OrderId : Int64; RequiredDate : DateTime option; ShipAddress : String voption; ShipCity : String option; ShipCountry : String option; ShipName : String option; ShipPostalCode : String option; ShipRegion : String option; ShippedDate : DateTime option }
+
+type OrderDetailsClassOpts() =
+    member val CustomerId = Some "" with get, set
+    member val ShipRegion = Some "" with get, set
+
+[<Test >]
+let ``simple select query with MapTo with options``() = 
+    let dc = sqlOption.GetDataContext()
+
+    let qry = 
+        query {
+            for ord in dc.Main.Orders do
+            select (ord)
+        } |> Seq.head
+    let mapped1 = qry.MapTo<OrderDetailsRecordOpts>()
+    let mapped2 = qry.MapTo<OrderDetailsClassOpts>()
+
+    Assert.AreEqual(Some "VINET", mapped1.CustomerId)
+    Assert.True(mapped1.ShipRegion.IsNone)
+    Assert.AreEqual(Some "VINET", mapped2.CustomerId)
+    Assert.True(mapped2.ShipRegion.IsNone)