Vp.FSharp.Sql Téléchargement - Vp.FSharp.Sql Code source Télécharger

`Vp.FSharp.Sql`

La bibliothèque de base qui vous permet de travailler avec F # et tout fournisseur ADO, de manière cohérente .

Dans la plupart des cas, cette bibliothèque est uniquement utilisée pour créer d'autres bibliothèques F # tirant parti des fournisseurs ADO pertinents.

Si vous souhaitez simplement exécuter les commandes SQL A-LA-F #, vous voudrez peut-être regarder cette section.

Battage médiatique

Nous suivons les «pratiques très controversées» au mieux de nos capacités!

Statut	Emballer
D'ACCORD
Ok (sorta)
TBD
TBD

Package Nuget

Nom	Version	Commande
`Vp.FSharp.Sql`		`Install-Package Vp.FSharp.Sql`

Comment utiliser cette bibliothèque?

Cette bibliothèque vise principalement à être une base pour construire d'autres bibliothèques avec les fournisseurs ADO.NET pertinents pour offrir une expérience fortement typée.

Vous pouvez consulter les bibliothèques ci-dessous, chaque exploiter Vp.FSharp.Sql et le fournisseur ADO.NET pertinent:

Nom	Fournisseur ADO.NET	Commande
`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`

En un mot, vous pouvez créer votre propre fournisseur complet, mais vous êtes libre d'aller avec seulement les choses dont vous avez besoin.

Passons à travers la mise en œuvre du fournisseur Vp.FSharp.Sql.Sqlite .

Type de valeur de la base de données

Vous avez d'abord besoin du type le plus important de tous, le type de valeur de base de données.

Dans le cas de SQLite, SqliteDbValue peut être modélisé comme une union simple discriminée (DU):

 /// 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

^{Source d'extrait | ancre}

Ces cas sont créés après la documentation officielle de SQLite.

Valeur de base

C'est là que nous convertissons le DU exposé dans l'API publique en une classe compatible réelle DbParameter qui peut être consommée à partir des fonctions de bibliothèque de base.

Dans la plupart des scénarios, l'implémentation consiste en des correspondances de modèle d'écriture sur les différents cas de type de valeur de base de données et à la création des types spécifiques DbParameter pertinents disponibles dans le fournisseur ADO.NET, le cas échéant:

 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

Remarque: Cette fonction n'a pas à être publique, seule le DU doit être public.

Dépendances de liaison: Type et fonction

Les SqlDependencies agissent comme la colle qui collent toutes les opérations spécifiques à ADO les plus importantes:

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

Une instance de ce type peut implémenter avec:

 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 }

Dans ce cas particulier, System.Data.SQLite , les types les plus spécifiques ne sont disponibles que via l'API non asynchrone.

Par exemple, nous utilisons command.ExecuteReader au lieu de command.ExecuteDbDataReader car le type de retour est le plus spécifique:

SQLiteCommand.ExecuteDbDataReader()
SQLiteCommand.ExecuteReader()

De plus, comme vous l'avez peut-être remarqué, il n'y a pas de survenue d'une API asynchrone, ce qui signifie que la «mise en œuvre» (ou l'absence de celui-ci) asynchrone repose sur l'implémentation de la classe de base:

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

Ce qui est juste un emballage asynchrone autour de la version synchrone.

De même, en ce qui concerne connection.BeginTransaction command.BeginTransactionAsync

SQLiteConnection.BeginTransaction()
DbConnection.BeginTransactionAsync()

Cet exemple seul montre le type de divergences que vous pouvez vous attendre à trouver dans les implémentations des fournisseurs ADO.NET les plus disponibles.

⌨ Définition de commande

Par souci de simplicité, vous pouvez contraindre le type de CommandDefinition avec les types de fournisseurs ADO pertinents, comme une sorte de liant de type:

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

Cela peut être utilisé plus tard avec les fonctions SqlCommand qui acceptent CommandDefinition comme l'un de leurs paramètres.

Configuration

Il y a encore une autre spécialisation en termes de contraintes génériques:

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

Ce type est un autre liant pour les types et agit comme un cache; Il sera transmis avec la définition de commande lors de l'exécution d'une commande.

Construction de commandement

C'est assez simple, tout ce que vous avez à faire est:

Créez un nouveau module (si vous le souhaitez).
Définissez les fonctions de construction pertinentes pour votre bibliothèque et transmettez la définition de commande aux fonctions Core SqlCommand .

 [<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

Exécution de la commande

De même, l'exécution des commandes suit les mêmes principes, alias passant les paramètres pertinents de type fortement (correspondant à votre fournisseur ADO.NET actuel et spécifique) aux fonctions de noyau SQLCommand.

 /// 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

Aides nuls

Nous pouvons créer un autre module pour les aides NULL, et le reste consiste à passer les paramètres pertinents aux fonctions de base sous-jacentes.

 [<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 )

Aiders de transaction

Plus de la même chose ici aussi.

 [<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

Et le tour est joué! Vous êtes maintenant tous réglés et prêts à exécuter les commandes les plus folles dans votre base de données préférée!

Aiders `TransactionScope`

Ces aides fonctionnent quel que soit le fournisseur ADO.NET que vous utilisez tant qu'il prend en charge TransactionScope .

Cela étant dit, nous vous décourageons fortement d'utiliser ces aides :

Gardez à l'esprit que la prise en charge des transactions distribuées n'est pas encore disponible depuis l'ère .NET Core.
L'utilisation TransactionScope (avec ou sans ces aides) est très sujet aux erreurs, et vous pouvez rencontrer des comportements inattendus sans messages d'erreur clairs.
Étant donné qu'il y a très peu d'évolution concernant cette prise en charge, et donc il existe en quelque sorte des applications limitées pour utiliser la TransactionScope sans la prise en charge des transactions distribuées, ces aides pourraient passer à une bibliothèque distincte (IE Repository + Package NuGet).

Si vous avez besoin d'une solution de contournement viable à 2pc ou des transactions distribuées, vous voudrez peut-être vérifier certains modèles architecturaux tels que le modèle SAGA.

Comment contribuer

Les rapports de bogues, les demandes de fonctionnalités et les demandes de traction sont les bienvenus!

Veuillez lire les directives de contribution pour commencer.

Licence

Le projet est autorisé en vertu du MIT.

Pour plus d'informations sur la licence, consultez le fichier de licence.

Développer

Vp.FSharp.Sql

`Vp.FSharp.Sql`

Battage médiatique

Package Nuget

Comment utiliser cette bibliothèque?

Type de valeur de la base de données

Valeur de base

Dépendances de liaison: Type et fonction

⌨ Définition de commande

Configuration

Construction de commandement

Exécution de la commande

Aides nuls

Aiders de transaction

Aiders `TransactionScope`

Comment contribuer

Licence

Application VP eSports

Asai empêche le script d'injection SQL v2.0

Programme de film Chengfeng v4.0 SQL

Programme de script d'injection anti-SQL ASP.NET (VB.NET)

Nouvelles fonctionnalités Microsoft.SQL.Server.2005

chat.petals.dev

GPT Prompt Templates

GPTyped

Ajax pas d'actualisation du code de vérification chinois

Système scolaire en ligne KesionEDU v9.0.211110

UrlRewriter .NET v2.0 RC1 (Pour .Net2.0) Version optimisée Wenmo Studio

Google Dorks

shepherd

mongo express

Vp.FSharp.Sql

Vp.FSharp.Sql

Battage médiatique

Package Nuget

Comment utiliser cette bibliothèque?

Type de valeur de la base de données

Valeur de base

Dépendances de liaison: Type et fonction

⌨ Définition de commande

Configuration

Construction de commandement

Exécution de la commande

Aides nuls

Aiders de transaction

Aiders TransactionScope

Comment contribuer

Licence

`Vp.FSharp.Sql`

Aiders `TransactionScope`