Vp.FSharp.Sql

Vp.FSharp.Sql

Die Kernbibliothek, mit der Sie konsequent mit F# und jedem Ado -Anbieter arbeiten können.

In den meisten Fällen wird diese Bibliothek nur zum Erstellen anderer F# -Bibliotheken verwendet, die die relevanten Ado -Anbieter nutzen.

Wenn Sie nur SQL-Befehle A-LA-F#ausführen möchten, möchten Sie sich diesen Abschnitt möglicherweise ansehen.

Schlanker Hype

Wir folgen "höchst kontroverse Praktiken" nach besten Kräften!

Status	Paket
OK
Ok (sorta)
TBD
TBD

Nuget -Paket

Name	Version	Befehl
Vp.FSharp.Sql		Install-Package Vp.FSharp.Sql

Wie benutze ich diese Bibliothek?

Diese Bibliothek zielt hauptsächlich darauf ab, eine Grundlage für den Aufbau anderer Bibliotheken mit den zuständigen ADO.NET-Anbietern zu bilden, um ein stark typisches Erlebnis zu bieten.

Sie können sich die folgenden Bibliotheken ansehen, die jeweils Vp.FSharp.Sql und den entsprechenden ADO.NET -Anbieter nutzen:

Name	Ado.net Anbieter	Version	Befehl
Vp.FSharp.Sql.Sqlite	System.Data.SQLite.Core		Install-Package Vp.FSharp.Sql.Sqlite
Vp.FSharp.Sql.SqlServer	Microsoft.Data.SqlClient		Install-Package Vp.FSharp.Sql.SqlServer
Vp.FSharp.Sql.PostgreSql	Npgsql		Install-Package Vp.FSharp.Sql.PostgreSql

Kurz gesagt, Sie können Ihren eigenen vollständigen Anbieter erstellen, aber Sie können nur mit nur den Dingen, die Sie brauchen, entscheiden.

Lassen Sie uns die Implementierung von Vp.FSharp.Sql.Sqlite -Anbieter durchlaufen.

Datenbankwerttyp

Erstens benötigen Sie den wichtigsten Typ aller, den Datenbankwerttyp.

Im Fall von SQLite kann SqliteDbValue als einfache diskriminierte Gewerkschaft (DU) modelliert werden:

 /// Native SQLite DB types.
/// See https://www.sqlite.org/datatype3.html
type SqliteDbValue =
    | Null
    | Integer of int64
    | Real of double
    | Text of string
    | Blob of byte array

^{Snippet -Quelle | Anker}

Diese Fälle werden nach der offiziellen SQLite -Dokumentation erstellt.

DB -Wert zur DB -Parameterkonvertierung

Hier konvertieren wir die in der öffentliche API ausgesetzte DU in eine tatsächliche DbParameter -kompatible Klasse, die aus den Kernbibliotheksfunktionen konsumiert werden kann.

In den meisten Szenarien besteht die Implementierung aus dem Schreiben von Musterübereinstimmungen in den verschiedenen Fällen des Datenbankwert -Typs und dem Erstellen der relevanten DbParameter Typen, die im ADO.NET -Anbieter verfügbar sind, falls vorhanden:

 let dbValueToParameter name value =
    let parameter = SQLiteParameter ()
    parameter.ParameterName <- name
    match value with
    | Null ->
        parameter.TypeName <- ( nameof Null ) .ToUpperInvariant ()
    | Integer value ->
        parameter.TypeName <- ( nameof Integer ) .ToUpperInvariant ()
        parameter.Value <- value
    | Real value ->
        parameter.TypeName <- ( nameof Real ) .ToUpperInvariant ()
        parameter.Value <- value
    | Text value ->
        parameter.TypeName <- ( nameof Text ) .ToUpperInvariant ()
        parameter.Value <- value
    | Blob value ->
        parameter.TypeName <- ( nameof Blob ) .ToUpperInvariant ()
        parameter.Value <- value
    parameter

Hinweis: Diese Funktion muss nicht öffentlich sein, sondern nur der DU muss öffentlich sein.

Bindungsabhängigkeiten: Typ und Funktion

Die SqlDependencies wirken wie der Kleber, der die wichtigsten zugrunde liegenden adospezifischen Operationen festhält:

 /// SQLite Dependencies
type SqliteDependencies =
    SqlDependencies <
        SQLiteConnection ,
        SQLiteCommand ,
        SQLiteParameter ,
        SQLiteDataReader ,
        SQLiteTransaction ,
        SqliteDbValue >

Eine Instanz dieses Typs kann implementiert werden mit:

 let beginTransactionAsync ( connection : SQLiteConnection ) ( isolationLevel : IsolationLevel ) _ =
    ValueTask.FromResult ( connection.BeginTransaction ( isolationLevel ))

let executeReaderAsync ( command : SQLiteCommand ) _ =
    Task.FromResult ( command.ExecuteReader ())

{ CreateCommand = fun connection -> connection.CreateCommand ()
  SetCommandTransaction = fun command transaction -> command.Transaction <- transaction
  BeginTransaction = fun connection -> connection.BeginTransaction
  BeginTransactionAsync = beginTransactionAsync
  ExecuteReader = fun command -> command.ExecuteReader ()
  ExecuteReaderAsync = executeReaderAsync
  DbValueToParameter = Constants.DbValueToParameter }

In diesem speziellen Fall, System.Data.SQLite , sind die spezifischsten Typen nur über die nicht asynchrone API verfügbar.

Zum Beispiel verwenden wir command.ExecuteReader anstelle von command.ExecuteDbDataReader , da der Rückgabetyp der spezifischste ist:

• SQLiteCommand.ExecuteDbDataReader()
• SQLiteCommand.ExecuteReader()

Wie Sie vielleicht bemerkt haben, gibt es keine asynchrone API, was bedeutet, dass sich die asynchrone "Implementierung" (oder mangelnde davon) auf der Implementierung der Basisklasse beruht:

• DbCommand.ExecuteReaderAsync()
• DbCommand.ExecuteDbDataReader(CommandBehavior behavior)

Das ist nur ein asynchroner Wrapper um die synchrone Version.

In ähnlicher Weise, wenn es um connection.BeginTransaction anstelle von command.BeginTransactionAsync geht.BeginTransactionAsync:

• SQLiteConnection.BeginTransaction()
• DbConnection.BeginTransactionAsync()

Allein in diesem Beispiel zeigt die Art von Diskrepanzen, die Sie in den am besten verfügbaren ADO.NET -Anbieter -Implementierungen erwarten können.

⌨ Befehlsdefinition

Aus Einfachheit halber können Sie den CommandDefinition mit den relevanten Ado -Anbieter -Typen als Typ -Binder einschränken:

 /// SQLite Command Definition
type SqliteCommandDefinition =
    CommandDefinition <
        SQLiteConnection ,
        SQLiteCommand ,
        SQLiteParameter ,
        SQLiteDataReader ,
        SQLiteTransaction ,
        SqliteDbValue >

Dies kann später mit den SqlCommand -Funktionen verwendet werden, die CommandDefinition als einen ihrer Parameter akzeptieren.

Konfiguration

Es gibt noch eine weitere Spezialisierung in Bezug auf generische Einschränkungen:

 /// SQLite Configuration
type SqliteConfiguration =
    SqlConfigurationCache <
        SQLiteConnection ,
        SQLiteCommand >

Dieser Typ ist ein weiterer Ordner für Typen und fungiert als Cache. Es wird zusammen mit der Befehlsdefinition bei der Ausführung eines Befehls übergeben.

Kommandokonstruktion

Dies ist ziemlich einfach, nur was Sie tun müssen, ist:

• Erstellen Sie ein neues Modul (wenn Sie möchten).
• Definieren Sie die für Ihre Bibliothek relevanten Baufunktionen und geben Sie die Befehlsdefinition an die SqlCommand -Kernfunktionen weiter.

 [<RequireQualifiedAccess>]
module Vp.FSharp.Sql.Sqlite.SqliteCommand

open Vp. FSharp . Sql


/// Initialize a new command definition with the given text contained in the given string.
let text value : SqliteCommandDefinition =
    SqlCommand.text value

/// Initialize a new command definition with the given text spanning over several strings (ie. list).
let textFromList value : SqliteCommandDefinition =
    SqlCommand.textFromList value

/// Update the command definition so that when executing the command, it doesn't use any logger.
/// Be it the default one (Global, if any.) or a previously overriden one.
let noLogger commandDefinition = { commandDefinition with Logger = LoggerKind.Nothing }

/// Update the command definition so that when executing the command, it use the given overriding logger.
/// instead of the default one, aka the Global logger, if any.
let overrideLogger value commandDefinition = { commandDefinition with Logger = LoggerKind.Override value }

/// Update the command definition with the given parameters.
let parameters value ( commandDefinition : SqliteCommandDefinition ) : SqliteCommandDefinition =
    SqlCommand.parameters value commandDefinition

/// Update the command definition with the given cancellation token.
let cancellationToken value ( commandDefinition : SqliteCommandDefinition ) : SqliteCommandDefinition =
    SqlCommand.cancellationToken value commandDefinition

/// Update the command definition with the given timeout.
/// Note: kludged because SQLite doesn't support per-command timeout values.
let timeout value ( commandDefinition : SqliteCommandDefinition ) : SqliteCommandDefinition =
    SqlCommand.timeout value commandDefinition

/// Update the command definition and sets whether the command should be prepared or not.
let prepare value ( commandDefinition : SqliteCommandDefinition ) : SqliteCommandDefinition =
    SqlCommand.prepare value commandDefinition

/// Update the command definition and sets whether the command should be wrapped in the given transaction.
let transaction value ( commandDefinition : SqliteCommandDefinition ) : SqliteCommandDefinition =
    SqlCommand.transaction value commandDefinition

Befehlsausführung

Ebenso folgt die Befehlsausführung den gleichen Prinzipien, wobei auch bekannt als die relevanten, stark typischen Parameter (entsprechend Ihrem aktuellen und spezifischen ADO.NET-Anbieter) an die SQLCommand-Kernfunktionen übertragen werden.

 /// Execute the command and return the sets of rows as an AsyncSeq accordingly to the command definition.
/// This function runs asynchronously.
let queryAsyncSeq connection read ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.queryAsyncSeq
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read commandDefinition

/// Execute the command and return the sets of rows as an AsyncSeq accordingly to the command definition.
/// This function runs synchronously.
let querySeqSync connection read ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySeqSync
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read commandDefinition

/// Execute the command and return the sets of rows as a list accordingly to the command definition.
/// This function runs asynchronously.
let queryList connection read ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.queryList
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read commandDefinition

/// Execute the command and return the sets of rows as a list accordingly to the command definition.
/// This function runs synchronously.
let queryListSync connection read ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.queryListSync
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read commandDefinition

/// Execute the command and return the first set of rows as a list accordingly to the command definition.
/// This function runs asynchronously.
let querySetList connection read ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySetList
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read commandDefinition

/// Execute the command and return the first set of rows as a list accordingly to the command definition.
/// This function runs synchronously.
let querySetListSync connection read ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySetListSync
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read commandDefinition

/// Execute the command and return the 2 first sets of rows as a tuple of 2 lists accordingly to the command definition.
/// This function runs asynchronously.
let querySetList2 connection read1 read2 ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySetList2
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read1 read2 commandDefinition

/// Execute the command and return the 2 first sets of rows as a tuple of 2 lists accordingly to the command definition.
/// This function runs synchronously.
let querySetList2Sync connection read1 read2 ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySetList2Sync
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read1 read2 commandDefinition

/// Execute the command and return the 3 first sets of rows as a tuple of 3 lists accordingly to the command definition.
/// This function runs asynchronously.
let querySetList3 connection read1 read2 read3 ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySetList3
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read1 read2 read3 commandDefinition

/// Execute the command and return the 3 first sets of rows as a tuple of 3 lists accordingly to the command definition.
/// This function runs synchronously.
let querySetList3Sync  connection read1 read2 read3 ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.querySetList3Sync
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) read1 read2 read3 commandDefinition

/// Execute the command accordingly to its definition and,
/// - return the first cell value, if it is available and of the given type.
/// - throw an exception, otherwise.
/// This function runs asynchronously.
let executeScalar < 'Scalar > connection ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.executeScalar < 'Scalar , _, _, _, _, _, _, _, _>
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) commandDefinition

/// Execute the command accordingly to its definition and,
/// - return the first cell value, if it is available and of the given type.
/// - throw an exception, otherwise.
/// This function runs synchronously.
let executeScalarSync < 'Scalar > connection ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.executeScalarSync < 'Scalar , _, _, _, _, _, _, _, _>
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) commandDefinition

/// Execute the command accordingly to its definition and,
/// - return Some, if the first cell is available and of the given type.
/// - return None, if first cell is DBNull.
/// - throw an exception, otherwise.
/// This function runs asynchronously.
let executeScalarOrNone < 'Scalar > connection ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.executeScalarOrNone < 'Scalar , _, _, _, _, _, _, _, _>
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) commandDefinition

/// Execute the command accordingly to its definition and,
/// - return Some, if the first cell is available and of the given type.
/// - return None, if first cell is DBNull.
/// - throw an exception, otherwise.
/// This function runs synchronously.
let executeScalarOrNoneSync < 'Scalar > connection ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.executeScalarOrNoneSync < 'Scalar , _, _, _, _, _, _, _, _>
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) commandDefinition

/// Execute the command accordingly to its definition and, return the number of rows affected.
/// This function runs asynchronously.
let executeNonQuery connection ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.executeNonQuery
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) commandDefinition

/// Execute the command accordingly to its definition and, return the number of rows affected.
/// This function runs synchronously.
let executeNonQuerySync connection ( commandDefinition : SqliteCommandDefinition ) =
    SqlCommand.executeNonQuerySync
        connection ( Constants.Deps ) ( SqliteConfiguration.Snapshot ) commandDefinition

Nullhelfer

Wir können ein anderes Modul für Nullhelfer erstellen, und es geht im Rest darum, die entsprechenden Parameter an die zugrunde liegenden Kernfunktionen zu übergeben.

 [<RequireQualifiedAccess>]
module Vp.FSharp.Sql.Sqlite.SqliteNullDbValue

open Vp. FSharp . Sql


/// Return SQLite DB Null value if the given option is None, otherwise the underlying wrapped in Some.
let ifNone toDbValue = NullDbValue.ifNone toDbValue SqliteDbValue.Null

/// Return SQLite DB Null value if the option is Error, otherwise the underlying wrapped in Ok.
let ifError toDbValue = NullDbValue.ifError toDbValue ( fun _ -> SqliteDbValue.Null ) 

Transaktionshelfer

Mehr davon auch hier.

 [<RequireQualifiedAccess>]
module Vp.FSharp.Sql.Sqlite.SqliteTransaction

open Vp. FSharp . Sql
open Vp. FSharp . Sql . Sqlite


let private beginTransactionAsync = Constants.Deps.BeginTransactionAsync
let private beginTransaction = Constants.Deps.BeginTransaction

/// Create and commit an automatically generated transaction with the given connection, isolation,
/// cancellation token and transaction body.
/// This function runs asynchronously.
let commit cancellationToken isolationLevel connection body =
    Transaction.commit cancellationToken isolationLevel connection beginTransactionAsync body

/// Create and commit an automatically generated transaction with the given connection, isolation,
/// and transaction body.
/// This function runs synchronously.
let commitSync isolationLevel connection body =
    Transaction.commitSync isolationLevel connection beginTransaction body

/// Create and do not commit an automatically generated transaction with the given connection, isolation,
/// cancellation token and transaction body.
/// This function runs asynchronously.
let notCommit cancellationToken isolationLevel connection body =
    Transaction.notCommit cancellationToken isolationLevel connection beginTransactionAsync body

/// Create and do not commit an automatically generated transaction with the given connection, isolation,
/// and transaction body.
/// This function runs synchronously.
let notCommitSync isolationLevel connection body =
    Transaction.notCommitSync isolationLevel connection beginTransaction body

/// Create and commit an automatically generated transaction with the given connection, isolation,
/// cancellation token and transaction body.
/// The commit phase only occurs if the transaction body returns Some.
/// This function runs asynchronously.
let commitOnSome cancellationToken isolationLevel connection body =
    Transaction.commitOnSome cancellationToken isolationLevel connection beginTransactionAsync body

/// Create and commit an automatically generated transaction with the given connection, isolation,
/// and transaction body.
/// The commit phase only occurs if the transaction body returns Some.
/// This function runs synchronously.
let commitOnSomeSync isolationLevel connection body =
    Transaction.commitOnSomeSync isolationLevel connection beginTransaction body

/// Create and commit an automatically generated transaction with the given connection, isolation,
/// cancellation token and transaction body.
/// The commit phase only occurs if the transaction body returns Ok.
/// This function runs asynchronously.
let commitOnOk cancellationToken isolationLevel connection body =
    Transaction.commitOnOk cancellationToken isolationLevel connection beginTransactionAsync body

/// Create and commit an automatically generated transaction with the given connection, isolation,
/// and transaction body.
/// The commit phase only occurs if the transaction body returns Ok.
/// This function runs synchronously.
let commitOnOkSync isolationLevel connection body =
    Transaction.commitOnOkSync isolationLevel connection beginTransaction body

/// Create and commit an automatically generated transaction with the given connection and transaction body.
/// This function runs asynchronously.
let defaultCommit connection body = Transaction.defaultCommit connection beginTransactionAsync body

/// Create and commit an automatically generated transaction with the given connection and transaction body.
/// This function runs synchronously.
let defaultCommitSync connection body = Transaction.defaultCommitSync connection beginTransaction body

/// Create and do not commit an automatically generated transaction with the given connection and transaction body.
/// This function runs asynchronously.
let defaultNotCommit connection body = Transaction.defaultNotCommit connection beginTransactionAsync body

/// Create and do not commit an automatically generated transaction with the given connection and transaction body.
/// This function runs synchronously.
let defaultNotCommitSync connection body = Transaction.defaultNotCommitSync connection beginTransaction body

/// Create and commit an automatically generated transaction with the given connection and transaction body.
/// The commit phase only occurs if the transaction body returns Ok.
/// This function runs asynchronously.
let defaultCommitOnSome connection body = Transaction.defaultCommitOnSome connection beginTransactionAsync body

/// Create and commit an automatically generated transaction with the given connection and transaction body.
/// The commit phase only occurs if the transaction body returns Ok.
/// This function runs synchronously.
let defaultCommitOnSomeSync connection body = Transaction.defaultCommitOnSomeSync connection beginTransaction body

/// Create and commit an automatically generated transaction with the given connection and transaction body.
/// The commit phase only occurs if the transaction body returns Some.
/// This function runs asynchronously.
let defaultCommitOnOk connection body = Transaction.defaultCommitOnOk connection beginTransactionAsync body

/// Create and commit an automatically generated transaction with the given connection and transaction body.
/// The commit phase only occurs if the transaction body returns Some.
/// This function runs synchronously.
let defaultCommitOnOkSync connection body = Transaction.defaultCommitOnOkSync connection beginTransaction body

Und voila! Sie sind jetzt alle festgelegt und bereit, die wildesten Befehle gegen Ihre Lieblingsdatenbank auszuführen!

TransactionScope -Helfer

Diese Helfer arbeiten unabhängig von dem ADO.NET -Anbieter, den Sie verwenden, solange er TransactionScope unterstützt.

Davon abgesehen entmutigen wir Sie nachdrücklich davon, diese Helfer zu verwenden :

• Beachten Sie, dass die Unterstützung für verteilte Transaktionen seit der ERA von .NET noch nicht verfügbar ist.
• Die Verwendung TransactionScope (mit oder ohne diese Helfer) ist sehr fehleranfällig, und Sie können auf unerwartete Verhaltensweisen ohne klare Fehlermeldungen stoßen.
• In Anbetracht der Tatsache, dass diese Unterstützung nur sehr wenig weiterentwickelt, gibt es daher irgendwie nur begrenzte Anwendungen, um das TransactionScope ohne Unterstützung für verteilte Transaktionen zu verwenden, können diese Helfer in eine separate Bibliothek (dh Repository + Nuget -Paket) wechseln.

Wenn Sie eine praktikable Problemumgehung zu 2PC- oder verteilten Transaktionen benötigen, sollten Sie einige architektonische Muster wie das SAGA -Muster überprüfen.

Wie man beiträgt

Fehlerberichte, Feature -Anfragen und Zuganfragen sind sehr willkommen!

Bitte lesen Sie die Beitragsrichtlinien, um loszulegen.

Lizenzierung

Das Projekt ist unter MIT lizenziert.

Weitere Informationen zur Lizenz finden Sie in der Lizenzdatei.