mausch / fssql Goto Github PK

View Code? Open in Web Editor NEW

67.0 7.0 15.0 2.58 MB

Functional wrapper around ADO.NET for F#

Home Page: https://www.openhub.net/p/FsSql

License: Apache License 2.0

F# 99.22% Shell 0.31% Dockerfile 0.06% Batchfile 0.40%

fssql's Introduction

FsSql provides a functional interface to ADO.NET for F# applications.

Features:

Connection management
DBNull <-> option type conversion
Async calls
Transaction computation expression
Composable mapping functions

And, of course, everything ADO.NET does, in an idiomatic, functional, way.

For general usage, see:

Configuring logging:


open System
open System.Diagnostics

open FsSql

type MyLogger(name) =
  interface Logging.Logger with
    member x.Log line =
      Debug.WriteLine (sprintf "%A" line)
    member x.Debug fLine =
      Debug.WriteLine (sprintf "%A" (fLine ()))
    member x.Verbose fLine =
      Debug.WriteLine (sprintf "%A" (fLine ()))

Logging.configure (fun () -> DateTime.UtcNow.Ticks)
                  (fun name -> new MyLogger(name))

fssql's People

Contributors

Stargazers

Watchers

Forkers

rojepp vasily-kirichenko jackfoxy geniussportsgroup haf modulexcite ingted theangrybyrd yukibonji cartermp irium wallymathieu

fssql's Issues

Ability to set command timeout

It'd be nice to have an ability to set timeout for an individual SqlWrapper methods.

Tests don't run on mono

insert then get (memory db): Exception: System.DllNotFoundException: System.Data.SQLite.DLL

asRecord fails when attempting to retrieve a column type of DateTimeOffset

Setup:
I used FluentMigration to create this table

This works fine and I can insert into this without issue

    override x.Up() =
        base.Create.Table(tableName)
                .WithColumn("c1").AsGuid().NotNullable().Unique()
                .WithColumn("c1").AsGuid().NotNullable()
                .WithColumn("c2").AsString().NotNullable()
                .WithColumn("c3").AsString().NotNullable()
                .WithColumn("TimeStamp").AsDateTimeOffset()
                |> ignore

When I do my select with the code below I get an exception

                Sql.asyncExecReader conn ( sprintf """
                    SELECT "c1","c2","c3","c4", "TimeStamp"
                    FROM "TableName"
                    WHERE "c2" = '%s'
                """ (c2.ToString())) []
                |> Async.map Seq.ofDataReader
                |> Async.map(Seq.map(Sql.asRecord<DataModel> ""))
                |> Async.map Seq.toList

This is an example of DataModel

        type DataModel = {
            c1 : Guid
            c2 : Guid
            c3 : string
            c4 : string
            TimeStamp : DateTimeOffset
        }

This is the exception I'm seeing

 System.ArgumentException: Object of type 'System.DateTime' cannot be converted to type 'System.DateTimeOffset'.
  at System.RuntimeType.CheckValue (System.Object value, System.Reflection.Binder binder, System.Globalization.CultureInfo culture, System.Reflection.BindingFlags invokeAttr) [0x0007d] in :0 
  at System.Reflection.MonoMethod.ConvertValues (System.Reflection.Binder binder, System.Object[] args, System.Reflection.ParameterInfo[] pinfo, System.Globalization.CultureInfo culture, System.Reflection.BindingFlags invokeAttr) [0x0007f] in :0 
  at System.Reflection.MonoCMethod.DoInvoke (System.Object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x0001a] in :0 
  at System.Reflection.MonoCMethod.Invoke (System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x00000] in :0 
  at [email protected] (System.Object[] args) [0x00001] in <5893d081904cf4daa745038381d09358>:0 
  at SqlModule+asRecord@410-1[a].Invoke (System.Data.IDataRecord r) [0x00056] in <54f790f208ebfa1aa7450383f290f754>:0

ScalaQuery

Get some inspiration from ScalaQuery: https://github.com/szeiger/scala-query

Lenses for mapping

Look into using lenses to build composable mappers.

No connection associated with this transaction

Getting a funky exception.

Callee (this crashes, when it gives the SqlConnectionManager as a parameter from the value from the tx workflow builder):

System.ArgumentNullException: Argument cannot be null.
Parameter name: No connection associated with this transaction
  at Mono.Data.Sqlite.SqliteTransaction.IsValid (Boolean throwError) [0x00011] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.0/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:148 
  at Mono.Data.Sqlite.SqliteTransaction.Rollback () [0x00000] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.0/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:127 
  at Tx.subscribe@113[Unit,Unit] (Microsoft.FSharp.Core.FSharpFunc`2 f, IDbTransaction tx, Microsoft.FSharp.Core.FSharpFunc`2 onCommit) [0x00000] in <filename unknown>:0 
  at Tx+transactional@125-1[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit].Invoke (IDbConnection conn) [0x00000] in <filename unknown>:0 
  at FsSqlPrelude.withResource[IDbConnection,TxResult`2] (Microsoft.FSharp.Core.FSharpFunc`2 create, Microsoft.FSharp.Core.FSharpFunc`2 dispose, Microsoft.FSharp.Core.FSharpFunc`2 action) [0x00000] in <filename unknown>:0 
  at Tx+Run@132[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit].Invoke (ConnectionManager cmgr) [0x00000] in <filename unknown>:0

SQL comp expr

Integrate Ademar's SQL computation expression: https://github.com/ademar/suave/blob/master/Suave/Data.fs

SQL type provider

Statically check SQL strings using a type provider, like Nemerle's SQL macro: http://nemerle.org/wiki/index.php?title=SQL_macros

Iteratees for result reading

Look into iteratees for result reading, instead of converting the datareader into a seq.

Here's a good introduction to iteratees: http://apocalisp.wordpress.com/2010/10/17/scalaz-tutorial-enumeration-based-io-with-iteratees/

Table-valued parameters

Look into making table-valued parameters easy to use: http://msdn.microsoft.com/en-us/library/bb675163.aspx

Suggestion: Add helper methods for iterating results immediately

Something I'm always copy/pasting in my F# projects are helper methods that do all the work of iterating reader/disposing of them afterwards.
Something like
let executeReaderWith (connectionString : string) (sql : string) (f : SqlDataReader -> 'a) : 'a seq =
seq {
use sqlr = executeReader connectionString sql
while sqlr.Read () do
yield f sqlr }

This leaves nice code for executing a query:
let fromReader r =
(r.GetString(0), r.GetString(1))
let results = executeReaderWith cn sql fromReader |> List.ofSeq

There would be some design issues to work through to make it fit in FsSql obviously. :)

Pagination

Create wrappers (one for each DBMS) to page queries

Mono build is broken

mono_build.sh is kinda obsolete now that xbuild is so much better.
However NuGet autorestore isn't working:

FsSql.fsproj: warning : Could not find project file /home/mauricio/Documents/FsSql//.nuget/nuget.targets

Schemas abstraction/removal

Example, works with SQLite:

let private insertMetric schema (m : Measure) connMgr =
  Sql.execNonQuery connMgr
    "INSERT INTO Metrics (Path, EpochTicks, Level, Type, Value)
     VALUES (@path, @epoch, @level, @type, @value)"
    [ P("@path", m.path)
      P("@epoch", m.timestamp.Ticks)
      P("@level", m.level.ToInt())
      P("@type", m.mtype.ToString())
      P("@value", m.value) ]

What I'd want for SQLServer:

let private insertMetric schema (m : Measure) connMgr =
  Sql.execNonQuery connMgr
    (sprintf "INSERT INTO %s.Metrics (Path, EpochTicks, Level, Type, Value)
     VALUES (@path, @epoch, @level, @type, @value)" schema)
    [ P("@path", m.path)
      P("@epoch", m.timestamp.Ticks)
      P("@level", m.level.ToInt())
      P("@type", m.mtype.ToString())
      P("@value", m.value) ]

Is there an existing way of doing schemas transparently in FsSql?

Functional unparsing

Implement Olivier's Danvy functional unparsing for extensible parameterized SQL. See this impl

Missing Method::withNewConnection

System:
Arch Linux/Mono 3.0.7/Postgresql

Am I doing something wrong? This might be a Mono issue as well.

I'm getting the following exception:

Missing method SqlModule::withNewConnection(FSharpFunc`2<Unit, IDbConnection>) in assembly /home/fsharp/projectname/bin/Debug/FsSql.dll, referenced in assembly /home/fsharp/projectname/bin/Debug/projectname.exe

Unhandled Exception:
System.MissingMethodException: Method not found: 'SqlModule.withNewConnection'.
[ERROR] FATAL UNHANDLED EXCEPTION: System.MissingMethodException: Method not found: 'SqlModule.withNewConnection'.

while running this code:

module Data 
    open System
    open System.Data
    open FsSql
    open Npgsql
    open Models

    let openConnection() =
        let conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=postgresuser;Database=dbname;")
        conn.Open()
        conn :> IDbConnection

    let connectionManager = Sql.withNewConnection openConnection

    let sql = SqlWrapper(connectionManager)
    let execute a = sql.ExecNonQuery a [] |> ignore
    let Param = Sql.Parameter.make

    let insertUser (username:string) (password:string) (email:string) =
        Sql.execNonQuery connectionManager
            "insert into users (username,password,email) values (@username,@password,@email)"
            [Param("@username", username); Param("@password", password); Param("@email", email)]

    let insertUserTest (username:string) (password:string) (email:string) =
        let result = insertUser username password email
        result.ToString()

An interesting aspect of this issue is that the following .fsx script works:

#r "/home/fsharp/projectname/Libs/FsSql.dll"
#r "/home/fsharp/projectname/Libs/Npgsql.dll"

open System
open System.Data
open Npgsql
open FsSql

let openConn() =
    let conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=postgresuser;;Database=dbname;")
    conn.Open()
    conn :> IDbConnection

let connMgr = Sql.withNewConnection openConn

let sql = SqlWrapper(connMgr)
let exec a = sql.ExecNonQuery a [] |> ignore

exec "drop table if exists users;"
exec "CREATE TABLE Users (id SERIAL PRIMARY KEY, username character varying(60) NOT NULL UNIQUE, password varchar(80) NOT NULL UNIQUE, email varchar(150) NOT NULL UNIQUE);"

Consider supporting .Net core

https://icanhasdot.net/result?github=logary~2Flogary

Release your fixes

Tx.transactionalWithIsolation broken on rollback

Summary

When using transactionalWithIsolation the library doesn't handle the disposal/close of the IDbConnection properly with respect to the interaction with the transaction.

Justification: it should not matter what isolation level I set on the transaction from a runtime-perspective, only from a database-transaction perspective. Corollary; there is always a transaction level active, even if it's implicit, so making it explicit should not matter.

Working test

    testCase "can execute serialisable tx" <| fun _ ->
      let cm = Sql.withNewConnection (fun () -> Conn.sqlite_open' InMemory)
      let select_one m = Sql.execScalar m "select 1" []
      let select_one =
        select_one
        |> Tx.transactional2
        |> Tx.transactionalWithIsolation IsolationLevel.Serializable
      let res = select_one cm
      Assert.Equal("Can execute tx", Tx.TxResult.Commit(Some 1L), res)

Failing test case

    testCase "can execute serialisable tx 2" <| fun _ ->
      let tx = Tx.TransactionBuilder()
      let cm = Sql.withNewConnection (fun () -> Conn.sqlite_open' InMemory)
      let select_one = tx {
        let! a = Tx.execScalar "select 1" []
        let a : int64 = a |> Option.get
        if 1 = 1 then // comment out this, next line, to make test pass
          do! Tx.rollback 3L
        let! b = Tx.execScalar "select 1" []
        let b : int64 = b |> Option.get
        return a + b
      }
      let select_one = select_one |> Tx.transactionalWithIsolation IsolationLevel.Serializable
      let res = select_one cm
      Assert.Equal("Can execute tx", Tx.TxResult.Rollback 3L, res)

Stack trace:

smoke/can execute serialisable tx 2: Exception: System.ArgumentNullException: Argument cannot be null.
Parameter name: No connection associated with this transaction
  at Mono.Data.Sqlite.SqliteTransaction.IsValid (Boolean throwError) [0x00011] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.0/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:148 
  at Mono.Data.Sqlite.SqliteTransaction.Rollback () [0x00000] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.0/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:127 
  at Tx+transactionalWithIsolation@13[Tx+TxResult`2[System.Int64,System.Int64]].Invoke (IDbConnection conn) [0x00000] in <filename unknown>:0 
  at FsSqlPrelude.withResource[IDbConnection,TxResult`2] (Microsoft.FSharp.Core.FSharpFunc`2 create, Microsoft.FSharp.Core.FSharpFunc`2 dispose, Microsoft.FSharp.Core.FSharpFunc`2 action) [0x00000] in <filename unknown>:0 
  at Tx.transactionalWithIsolation[TxResult`2] (IsolationLevel isolation, Microsoft.FSharp.Core.FSharpFunc`2 f, ConnectionManager cmgr) [0x00000] in <filename unknown>:0 
  at [email protected] (ConnectionManager cmgr) [0x00000] in /Users/henrik.feldt/dev/logibit/logibit.web/src/logibit.sqlite.tests/Smoke.fs:67 
  at [email protected] (Microsoft.FSharp.Core.Unit _arg5) [0x0003e] in /Users/henrik.feldt/dev/logibit/logibit.web/src/logibit.sqlite.tests/Smoke.fs:68 
  at [email protected] (System.Tuple`2 tupledArg) [0x00000] in <filename unknown>:0

Dynamic operator not working - improved documentation needed?

I'm following the docs and trying to get a basic example working where I read some values out of my database. F# insists that (row?mood).Value is an indeterminate type. It's not clear from the example blog posts, or the unit tests, why this wouldn't work.

The relevant portions of my code:

open FsSql
// declare execReader etc. shortcuts as outlined in blog post

let private sleepOfSql (row:IDataRecord) =
    let x = (row?mood).Value
    // do more stuff

execReader "select * from sleeps where userId = @userId and @start <= date and date <= @fin" [P("@userId", userId'); P("@start", start); P("@fin", fin)]
|> Seq.ofDataReader
|> Seq.map (sleepOfSql)

Suggestion: Put it on Nuget!

It'd be nice to have this on Nuget.

SQLite: "Library used incorrectly"

I'm getting an error if I call return Rollback from within a nested transactional function with Mono.Data.SQLite (or SQLite in general).

  let internal op eid = Tx.execNonQueryi "insert into ..." [ P(...) ]

  let handle  (mgr : Sql.ConnectionManager) (eid : string) (fCont : Sql.ConnectionManager -> _) =
    let execTx = tx {
      do! op eid
      let! ret = fCont
      return ret
    }

    try
      match execTx mgr with
      ... etc
    with
    | :? Mono.Data.Sqlite.SqliteException as e ->
      LogLine.create' LogLevel.Fatal "unhandled exception in read model" |> LogLine.setExn e |> LogLine.setDatas [
        "receive_tx_id", box receiveTxId
        "error_code", box e.ErrorCode
        "stack_trace", box e.StackTrace
      ] |> Logger.log logger
      reraise ()

The 'Misuse' status code comes from the exception SqliteException.

F 2015-04-29T15:40:12.8422210+00:00: unhandled exception in read model
  error_code => Misuse
  receive_tx_id => "xxxxxxx"
  stack_trace => "  at Mono.Data.Sqlite.SqliteTransaction.IsValid (Boolean throwError) [0x00094] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.1/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:168
  at Mono.Data.Sqlite.SqliteTransaction.Rollback () [0x00000] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.1/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:127
  at Tx+onFailed@131-1[System.Exception].Invoke (IDbTransaction tran, System.Exception _arg3) [0x00000] in <filename unknown>:0
  at Microsoft.FSharp.Core.FSharpFunc`2[System.Data.IDbTransaction,System.Exception].InvokeFast[Unit] (Microsoft.FSharp.Core.FSharpFunc`2 func, IDbTransaction arg1, System.Exception arg2) [0x00000] in <filename unknown>:0
  at Tx.subscribe@113[Unit,Unit] (Microsoft.FSharp.Core.FSharpFunc`2 f, IDbTransaction tx, Microsoft.FSharp.Core.FSharpFunc`2 onCommit, Microsoft.FSharp.Core.FSharpFunc`2 onRollback, Microsoft.FSharp.Core.FSharpFunc`2 onFailed) [0x00000] in <filename unknown>:0
  at Tx+transactional@127-1[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit].Invoke (IDbConnection conn) [0x00000] in <filename unknown>:0
  at FsSqlPrelude.withResource[IDbConnection,TxResult`2] (Microsoft.FSharp.Core.FSharpFunc`2 create, Microsoft.FSharp.Core.FSharpFunc`2 dispose, Microsoft.FSharp.Core.FSharpFunc`2 action) [0x00000] in <filename unknown>:0
  at Tx+Run@134[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit].Invoke (ConnectionManager cmgr) [0x00000] in <filename unknown>:0
  at Mod.handle[Unit,Unit] (ConnectionManager mgr, System.String eid, Microsoft.FSharp.Core.FSharpFunc`2 fCont) [0x00000] in <filename unknown>:0 " cont...
Mono.Data.Sqlite.SqliteException: Library used incorrectly
No transaction is active on this connection
  at Mono.Data.Sqlite.SqliteTransaction.IsValid (Boolean throwError) [0x00094] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.1/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:168
  at Mono.Data.Sqlite.SqliteTransaction.Rollback () [0x00000] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.1/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteTransaction.cs:127
  at Tx+onFailed@131-1[System.Exception].Invoke (IDbTransaction tran, System.Exception _arg3) [0x00000] in <filename unknown>:0
  at Microsoft.FSharp.Core.FSharpFunc`2[System.Data.IDbTransaction,System.Exception].InvokeFast[Unit] (Microsoft.FSharp.Core.FSharpFunc`2 func, IDbTransaction arg1, System.Exception arg2) [0x00000] in <filename unknown>:0
  at Tx.subscribe@113[Unit,Unit] (Microsoft.FSharp.Core.FSharpFunc`2 f, IDbTransaction tx, Microsoft.FSharp.Core.FSharpFunc`2 onCommit, Microsoft.FSharp.Core.FSharpFunc`2 onRollback, Microsoft.FSharp.Core.FSharpFunc`2 onFailed) [0x00000] in <filename unknown>:0
  at Tx+transactional@127-1[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit].Invoke (IDbConnection conn) [0x00000] in <filename unknown>:0
  at FsSqlPrelude.withResource[IDbConnection,TxResult`2] (Microsoft.FSharp.Core.FSharpFunc`2 create, Microsoft.FSharp.Core.FSharpFunc`2 dispose, Microsoft.FSharp.Core.FSharpFunc`2 action) [0x00000] in <filename unknown>:0
  at Tx+Run@134[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit].Invoke (ConnectionManager cmgr) [0x00000] in <filename unknown>:0
  at Mod.handle[Unit,Unit] (ConnectionManager mgr, System.String eid, Microsoft.FSharp.Core.FSharpFunc`2 fCont) [0x00000] in <filename unknown>:0

This issue doesn't seem to have anything to do with the other two issues I commented on earlier today.

This issue should trigger reliably by throwing an exception from fCont.

"System.InvalidOperationException: DataReader has been closed" with Sql.map

Is there any nice ways of reading a sequence of mapped results lazily after opening a data reader, without getting 'System.InvalidOperationException: DataReader has been closed`?

Feature Request: let FsSql know schema

As a user,
Doing joins,
I may not want to duplicate all DTOs,
But if I don't, I get these exceptions:

Exception: Mono.Data.Sqlite.SqliteException: SQLite error
no such column: r.images
  at Mono.Data.Sqlite.SQLite3.Prepare (Mono.Data.Sqlite.SqliteConnection cnn, System.String strSql, Mono.Data.Sqlite.SqliteStatement previous, UInt32 timeoutMS, System.String& strRemain) [0x0022a] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.0/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLite3.cs:343 
  at Mono.Data.Sqlite.SqliteCommand.BuildNextCommand () [0x00019] in /private/tmp/source-mono-mac-3.12.0-branch-32/bockbuild-mono-3.12.0-branch/profiles/mono-mac-xamarin/build-root/mono-3.12.0/mcs/class/Mono.Data.Sqlite/Mono.Data.Sqlite_2.0/SQLiteCommand.cs:230  (00:00:00.1324668)

When r.images is the field that is a 'string list' that I want to join another table into.

The code looks like: select %s, i.path from my_table t join images i on t.id = i.t_id with a Sql.recordFieldsAlias typeof<MyTable> "t")

But MyTable contains a property images which in this case results from the i.path field.

If FsSql kept track on the schemas for the tageted table MyTable, then it would know to exclude images from the list of 'record field aliases'.

Or perhaps I could just give it an 'exclude' list?

Otherwise, do you create duplicate DTOs for just mapping and then mapping code from your 'internal' DTOs to you 'external' DTOs? It seems like such a waste to write all that extra code.

DbType inference

DbType = Unchecked.defaultof<DbType> means AnsiString, which is incorrect. Use an option, set by default to None, then if None, don't set the actual parameter's DbType property.

Provide build scripts for building nugets

Right now mono NuGet.exe pack doesn't produce usable nugets. I haven't investigated further.

Parallel async - connection closed

Got a "connection closed" exception when trying to do Async.Parallel on a list of async execNonQuery.
Try to reproduce in tests, fix.

asRecord support for single-case discriminated unions

Please add support for asRecord deserializing fields into single-case discriminated unions. For example, I have a type Int6 = Int6 of int, which I just use for ints 0 <= i <= 5. When I try to deserialize my int32 database field through asRecord, I get:

System.ArgumentException: Object type System.Int32 cannot be converted to target type: sleep_log.DomainTypes+Int6

I make extensive use of single-case discriminated unions, so having asRecord see that e.g., my int32 database field corresponds to a T<int> record field would be super cool.