Download Vp.FSharp.Sql - Vp.FSharp.Sql download de código fonte

`Vp.FSharp.Sql`

A biblioteca principal que permite trabalhar com F# e qualquer provedor de ADO, de forma consistente .

Na maioria dos casos, essa biblioteca é usada apenas para criar outras bibliotecas F# alavancando os provedores de ADO relevantes.

Se você deseja apenas executar comandos SQL A-LA-F#, convém olhar para esta seção.

Hype de escago

Seguimos "práticas altamente controversas" da melhor maneira possível!

Status	Pacote
OK
Ok (meio)
TBD
TBD

Pacote Nuget

Nome	Versão	Comando
`Vp.FSharp.Sql`		`Install-Package Vp.FSharp.Sql`

Como usar esta biblioteca?

Esta biblioteca pretende ser uma base para a construção de outras bibliotecas com os provedores relevantes do ADO.NET para fornecer uma experiência fortemente tipada.

Você pode conferir as bibliotecas abaixo, cada um Vp.FSharp.Sql e o provedor ADO.NET relevante:

Nome	Provedor ADO.NET	Comando
`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`

Em poucas palavras, você pode criar seu próprio provedor completo, mas você está livre para usar apenas as coisas que precisa.

Vamos percorrer a implementação do provedor do provedor de provedores Vp.FSharp.Sql.Sqlite .

Tipo de valor do banco de dados

Primeiro você precisa do tipo mais importante de todos, o tipo de valor do banco de dados.

No caso do SQLite, SqliteDbValue pode ser modelado como uma união discriminada simples (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

^{Fonte do trecho | âncora}

Esses casos são criados após a documentação oficial do SQLite.

Valor de banco de dados para conversão de parâmetros de banco de dados

É aqui que convertemos o DU exposto na API público para uma classe compatível DbParameter que pode ser consumida a partir das funções da biblioteca principal.

Na maioria dos cenários, a implementação consiste em correspondência de padrões de escrita nos diferentes casos de valor do banco de dados e na criação dos tipos específicos relevantes DbParameter disponíveis no provedor ADO.NET, se houver:

 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 função não precisa ser pública, apenas o DU deve ser público.

Dependências de ligação: tipo e função

O SqlDependencies age como a cola que gruda todas as operações mais importantes subjacentes específicas do ADO:

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

Uma instância desse tipo pode implementar com:

 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 }

Nesse caso em particular, System.Data.SQLite , os tipos mais específicos estão disponíveis apenas através da API não asíncrona.

Por exemplo, usamos command.ExecuteReader em vez de command.ExecuteDbDataReader porque o tipo de retorno é o mais específico:

SQLiteCommand.ExecuteDbDataReader()
SQLiteCommand.ExecuteReader()

Além disso, como você deve ter notado, não há ocorrência de uma API assíncrona, o que significa que a "implementação" assíncrona (ou a falta delas) se baseia na implementação da classe base:

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

que é apenas um invólucro assíncrono em torno da versão síncrona.

Da mesma forma, quando se trata de connection.BeginTransaction command.BeginTransactionAsync

SQLiteConnection.BeginTransaction()
DbConnection.BeginTransactionAsync()

Somente este exemplo mostra o tipo de discrepâncias que você pode esperar encontrar nas implementações mais disponíveis do provedor ADO.NET.

⌨ Definição de comando

Por uma questão de simplicidade, você pode restringir o tipo CommandDefinition com os tipos de provedor de ADO relevantes, como algum tipo de aglutinante:

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

Isso pode ser mais tarde usado com as funções SqlCommand que aceitam CommandDefinition como um de seus parâmetros.

Configuração

Há ainda outra especialização em termos de restrições genéricas:

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

Este tipo é outro fichário para tipos e atua como um cache; Ele será passado junto com a definição de comando ao executar um comando.

Construção de comando

Isso é bastante simples, tudo o que você precisa fazer é:

Crie um novo módulo (se desejar).
Defina as funções de construção relevantes para sua biblioteca e passe a definição de comando para as funções principais 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

Execução de comando

Da mesma forma, a execução do comando segue os mesmos princípios, também conhecidos como parâmetros fortemente relevantes (correspondentes ao seu provedor ADO.NET atual e específico) para as funções principais do 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

Ajudantes nulos

Podemos criar outro módulo para ajudantes nulos, e o restante trata -se de passar os parâmetros relevantes para as funções principais subjacentes.

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

Ajudantes de transação

Mais do mesmo aqui também.

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

E pronto! Agora você está resolvido e pronto para executar os comandos mais loucos no seu banco de dados favorito!

`TransactionScope` Helpers

Esses ajudantes trabalham independentemente do provedor ADO.NET que você está usando, desde que suporta TransactionScope .

Dito isto, desencorajamos você de usar esses ajudantes :

Lembre -se de que o suporte para transações distribuídas ainda não está disponível desde a Era .NET Core.
O uso TransactionScope (com ou sem esses ajudantes) é muito propenso a erros e você pode encontrar comportamentos inesperados sem mensagens de erro claras.
Considerando que há muito pouca evolução em relação a esse suporte e, portanto, há de alguma forma aplicativos limitados para usar o TransactionScope sem o suporte para transações distribuídas, esses ajudantes podem passar para uma biblioteca separada (ou seja, o pacote Repositório + Nuget).

Se você precisar de uma solução alternativa viável para 2pc ou transações distribuídas, convém verificar alguns padrões arquitetônicos, como o padrão da saga.

Como contribuir

Relatórios de bugs, solicitações de recursos e solicitações de tração são muito bem -vindas!

Leia as diretrizes de contribuição para começar.

Licenciamento

O projeto está licenciado no MIT.

Para obter mais informações sobre a licença, consulte o arquivo de licença.

Expandir

Vp.FSharp.Sql

`Vp.FSharp.Sql`

Hype de escago

Pacote Nuget

Como usar esta biblioteca?

Tipo de valor do banco de dados

Valor de banco de dados para conversão de parâmetros de banco de dados

Dependências de ligação: tipo e função

⌨ Definição de comando

Configuração

Construção de comando

Execução de comando

Ajudantes nulos

Ajudantes de transação

`TransactionScope` Helpers

Como contribuir

Licenciamento

Aplicativo VP de eSports

Asai impede script de injeção SQL v2.0

Programa de filmes Chengfeng v4.0 Sql

Programa de script de injeção anti-SQL ASP.NET (VB.NET)

Novos recursos do Microsoft.SQL.Server.2005

chat.petals.dev

GPT Prompt Templates

GPTyped

Ajax sem atualização do código de verificação chinês

Sistema escolar on-line KesionEDU v9.0.211110

UrlRewriter .NET v2.0 RC1 (para .Net2.0) Versão otimizada do Wenmo Studio

Google Dorks

shepherd

mongo express

Vp.FSharp.Sql

Vp.FSharp.Sql

Hype de escago

Pacote Nuget

Como usar esta biblioteca?

Tipo de valor do banco de dados

Valor de banco de dados para conversão de parâmetros de banco de dados

Dependências de ligação: tipo e função

⌨ Definição de comando

Configuração

Construção de comando

Execução de comando

Ajudantes nulos

Ajudantes de transação

TransactionScope Helpers

Como contribuir

Licenciamento

`Vp.FSharp.Sql`

`TransactionScope` Helpers