Vp.FSharp.Sql DESCARGA - Vp.FSharp.Sql Código fuente de descarga

`Vp.FSharp.Sql`

La biblioteca central que le permite trabajar con F# y cualquier proveedor de ADO, de manera consistente .

En la mayoría de los casos, esta biblioteca solo se usa para crear otras bibliotecas F# que aprovechan los proveedores de ADO relevantes.

Si solo desea ejecutar los comandos SQL A-La-F#, es posible que desee mirar esta sección.

Exageración

¡Seguimos "prácticas muy controvertidas" lo mejor que podamos!

Estado	Paquete
DE ACUERDO
Ok (sorta)
TBD
TBD

Paquete nuget

Nombre	Versión	Dominio
`Vp.FSharp.Sql`		`Install-Package Vp.FSharp.Sql`

¿Cómo usar esta biblioteca?

Esta biblioteca tiene como objetivo ser una base para construir otras bibliotecas con los proveedores relevantes de ADO.NET para proporcionar una experiencia fuertemente tipada.

Puede consultar las bibliotecas a continuación, cada una aprovechando Vp.FSharp.Sql y el proveedor relevante de ADO.NET:

Nombre	Proveedor de ADO.NET	Dominio
`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 pocas palabras, puede crear su propio proveedor completo, pero usted es libre de ir solo con las cosas que necesita.

Cabemos la implementación del proveedor Vp.FSharp.Sql.Sqlite .

Tipo de valor de base de datos

Primero necesita el tipo más importante de todo, el tipo de valor de la base de datos.

En el caso de SQLite, SqliteDbValue puede modelarse como una unión discriminada (DU) simple:

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

^{Fuente de fragmento | ancla}

Estos casos se crean después de la documentación oficial de SQLite.

Valor de DB a la conversión de parámetros de DB

Aquí es donde convertimos el DU expuesto en la API pública a una clase compatible con DbParameter real que se puede consumir a partir de las funciones de la biblioteca central.

En la mayoría de los escenarios, la implementación consta de coincidencias de patrones de escritura en los diferentes casos de tipo de valor de base de datos y creando los tipos específicos relevantes DbParameter disponibles en el proveedor ADO.NET, si los hay:

 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

Nota: Esta función no tiene que ser pública, solo el DU tiene que ser público.

Dependencias vinculantes: tipo y función

Las SqlDependencies actúan como el pegamento que adquiere todas las operaciones más importantes específicas de ADO subyacentes:

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

Una instancia de este tipo puede implementarse con:

 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 }

En este caso particular, System.Data.SQLite , los tipos más específicos solo están disponibles a través de la API no asíncrona.

Por ejemplo, usamos command.ExecuteReader en lugar de command.ExecuteDbDataReader porque el tipo de retorno es el más específico:

SQLiteCommand.ExecuteDbDataReader()
SQLiteCommand.ExecuteReader()

Además, como puede haber notado, no hay ocurrencia de una API asincrónica, lo que significa que la "implementación" asincrónica (o falta de ellas) se basa en la implementación de la clase base:

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

que es solo un envoltorio asíncrono alrededor de la versión sincrónica.

Del mismo modo, cuando se trata de connection.BeginTransaction command.BeginTransactionAsync

SQLiteConnection.BeginTransaction()
DbConnection.BeginTransactionAsync()

Este ejemplo solo muestra el tipo de discrepancias que puede esperar encontrar en las implementaciones de proveedores ADO.NET más disponibles.

⌨ Definición de comando

En aras de la simplicidad, puede restringir el tipo CommandDefinition con los tipos de proveedores ADO relevantes, como algún tipo de aglutinante de tipo:

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

Esto se puede utilizar más tarde con las funciones SqlCommand que aceptan CommandDefinition como uno de sus parámetros.

Configuración

Hay otra especialización en términos de restricciones genéricas:

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

Este tipo es otra carpeta para tipos y actúa como un caché; Se pasará junto con la definición de comando al ejecutar un comando.

Construcción de comandos

Esto es bastante sencillo, todo lo que necesitas hacer es:

Cree un nuevo módulo (si lo desea).
Defina las funciones de construcción relevantes para su biblioteca y pase la definición de comando a las funciones básicas 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

Ejecución de comando

Del mismo modo, la ejecución de comandos sigue los mismos principios, también conocido como pasar los parámetros relevantes fuertemente tipados (correspondientes a su proveedor ADO.NET actual y específico) a las funciones básicas de 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

Ayudantes nulos

Podemos crear otro módulo para ayudantes nulos, y el resto se trata de pasar los parámetros relevantes a las funciones centrales subyacentes.

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

Ayudantes de transacciones

Más de lo mismo aquí también.

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

¡Y listo! ¡Ahora están todos listos y listo para ejecutar los comandos más salvajes contra su base de datos favorita!

`TransactionScope` ayudantes decope

Estos ayudantes funcionan independientemente del proveedor ADO.NET que esté utilizando siempre que admita TransactionScope .

Dicho esto, te desanimamos encarecidamente de usar esos ayudantes :

Tenga en cuenta que el soporte para transacciones distribuidas aún no está disponible desde la era del núcleo .NET.
El uso de TransactionScope (con o sin esos ayudantes) es muy propenso a errores, y puede encontrar comportamientos inesperados sin mensajes de error claros.
Teniendo en cuenta que hay muy poca evolución con respecto a este soporte y, por lo tanto, de alguna manera hay aplicaciones limitadas para usar TransactionScope sin el soporte para transacciones distribuidas, esos ayudantes pueden pasar a una biblioteca separada (es decir, repositorio + paquete nuget).

Si necesita una solución viable a 2PC o transacciones distribuidas, es posible que desee verificar algunos patrones arquitectónicos como el patrón SAGA.

Cómo contribuir

¡Los informes de errores, las solicitudes de funciones y las solicitudes de extracción son muy bienvenidas!

Lea las pautas de contribución para comenzar.

Licencia

El proyecto tiene licencia bajo MIT.

Para obtener más información sobre la licencia, consulte el archivo de licencia.

Expandir

Vp.FSharp.Sql

`Vp.FSharp.Sql`

Exageración

Paquete nuget

¿Cómo usar esta biblioteca?

Tipo de valor de base de datos

Valor de DB a la conversión de parámetros de DB

Dependencias vinculantes: tipo y función

⌨ Definición de comando

Configuración

Construcción de comandos

Ejecución de comando

Ayudantes nulos

Ayudantes de transacciones

`TransactionScope` ayudantes decope

Cómo contribuir

Licencia

Aplicación VP eSports

Asai evita el script de inyección SQL v2.0

Programa de películas Chengfeng v4.0 Sql

Programa de script de inyección anti-SQL ASP.NET (VB.NET)

Nuevas características de Microsoft.SQL.Server.2005

chat.petals.dev

GPT Prompt Templates

GPTyped

Ajax no actualiza el código de verificación chino

Sistema escolar en línea KesionEDU v9.0.211110

UrlRewriter .NET v2.0 RC1 (para .Net2.0) Versión optimizada de Wenmo Studio

Google Dorks

shepherd

mongo express

Vp.FSharp.Sql

Vp.FSharp.Sql

Exageración

Paquete nuget

¿Cómo usar esta biblioteca?

Tipo de valor de base de datos

Valor de DB a la conversión de parámetros de DB

Dependencias vinculantes: tipo y función

⌨ Definición de comando

Configuración

Construcción de comandos

Ejecución de comando

Ayudantes nulos

Ayudantes de transacciones

TransactionScope ayudantes decope

Cómo contribuir

Licencia

`Vp.FSharp.Sql`

`TransactionScope` ayudantes decope