1131 lines
52 KiB
Forth
1131 lines
52 KiB
Forth
namespace BitBadger.Documents.Postgres
|
|
|
|
/// The type of index to generate for the document
|
|
[<Struct>]
|
|
type DocumentIndex =
|
|
|
|
/// A GIN index with standard operations (all operators supported)
|
|
| Full
|
|
|
|
/// A GIN index with JSONPath operations (optimized for @>, @?, @@ operators)
|
|
| Optimized
|
|
|
|
|
|
open Npgsql
|
|
|
|
/// Configuration for document handling
|
|
module Configuration =
|
|
|
|
/// The data source to use for query execution
|
|
let mutable private dataSourceValue : NpgsqlDataSource option = None
|
|
|
|
/// Register a data source to use for query execution (disposes the current one if it exists)
|
|
[<CompiledName "UseDataSource">]
|
|
let useDataSource source =
|
|
if Option.isSome dataSourceValue then dataSourceValue.Value.Dispose()
|
|
dataSourceValue <- Some source
|
|
|
|
/// Retrieve the currently configured data source
|
|
[<CompiledName "DataSource">]
|
|
let dataSource () =
|
|
match dataSourceValue with
|
|
| Some source -> source
|
|
| None -> invalidOp "Please provide a data source before attempting data access"
|
|
|
|
|
|
open Npgsql.FSharp
|
|
|
|
/// Helper functions
|
|
[<AutoOpen>]
|
|
module private Helpers =
|
|
|
|
/// Shorthand to retrieve the data source as SqlProps
|
|
let internal fromDataSource () =
|
|
Configuration.dataSource () |> Sql.fromDataSource
|
|
|
|
/// Execute a task and ignore the result
|
|
let internal ignoreTask<'T> (it : System.Threading.Tasks.Task<'T>) = backgroundTask {
|
|
let! _ = it
|
|
()
|
|
}
|
|
|
|
/// Create a number or string parameter, or use the given parameter derivation function if non-(numeric or string)
|
|
let internal parameterFor<'T> (value: 'T) (catchAllFunc: 'T -> SqlValue) =
|
|
match box value with
|
|
| :? int8 as it -> Sql.int8 it
|
|
| :? uint8 as it -> Sql.int8 (int8 it)
|
|
| :? int16 as it -> Sql.int16 it
|
|
| :? uint16 as it -> Sql.int16 (int16 it)
|
|
| :? int as it -> Sql.int it
|
|
| :? uint32 as it -> Sql.int (int it)
|
|
| :? int64 as it -> Sql.int64 it
|
|
| :? uint64 as it -> Sql.int64 (int64 it)
|
|
| :? decimal as it -> Sql.decimal it
|
|
| :? single as it -> Sql.double (double it)
|
|
| :? double as it -> Sql.double it
|
|
| :? string as it -> Sql.string it
|
|
| _ -> catchAllFunc value
|
|
|
|
|
|
open BitBadger.Documents
|
|
|
|
/// Functions for creating parameters
|
|
[<AutoOpen>]
|
|
module Parameters =
|
|
|
|
/// Create an ID parameter (name "@id")
|
|
[<CompiledName "Id">]
|
|
let idParam (key: 'TKey) =
|
|
"@id", parameterFor key (fun it -> Sql.string (string it))
|
|
|
|
/// Create a parameter with a JSON value
|
|
[<CompiledName "Json">]
|
|
let jsonParam (name: string) (it: 'TJson) =
|
|
name, Sql.jsonb (Configuration.serializer().Serialize it)
|
|
|
|
/// Create JSON field parameters
|
|
[<CompiledName "AddFields">]
|
|
let addFieldParams fields parameters =
|
|
let name = ParameterName()
|
|
fields
|
|
|> Seq.map (fun it ->
|
|
seq {
|
|
match it.Comparison with
|
|
| Exists | NotExists -> ()
|
|
| Between (min, max) ->
|
|
let p = name.Derive it.ParameterName
|
|
yield ($"{p}min", parameterFor min (fun v -> Sql.parameter (NpgsqlParameter($"{p}min", v))))
|
|
yield ($"{p}max", parameterFor max (fun v -> Sql.parameter (NpgsqlParameter($"{p}max", v))))
|
|
| In values ->
|
|
let p = name.Derive it.ParameterName
|
|
yield!
|
|
values
|
|
|> Seq.mapi (fun idx v ->
|
|
let paramName = $"{p}_{idx}"
|
|
paramName, Sql.parameter (NpgsqlParameter(paramName, v)))
|
|
| InArray (_, values) ->
|
|
let p = name.Derive it.ParameterName
|
|
yield (p, Sql.stringArray (values |> Seq.map string |> Array.ofSeq))
|
|
| Equal v | Greater v | GreaterOrEqual v | Less v | LessOrEqual v | NotEqual v ->
|
|
let p = name.Derive it.ParameterName
|
|
yield (p, parameterFor v (fun l -> Sql.parameter (NpgsqlParameter(p, l)))) })
|
|
|> Seq.collect id
|
|
|> Seq.append parameters
|
|
|> Seq.toList
|
|
|> Seq.ofList
|
|
|
|
/// Append JSON field name parameters for the given field names to the given parameters
|
|
[<CompiledName "FieldNames">]
|
|
let fieldNameParams (fieldNames: string seq) =
|
|
if Seq.length fieldNames = 1 then "@name", Sql.string (Seq.head fieldNames)
|
|
else "@name", Sql.stringArray (Array.ofSeq fieldNames)
|
|
|
|
/// An empty parameter sequence
|
|
[<CompiledName "None">]
|
|
let noParams =
|
|
Seq.empty<string * SqlValue>
|
|
|
|
|
|
/// Query construction functions
|
|
[<RequireQualifiedAccess>]
|
|
module Query =
|
|
|
|
/// Create a WHERE clause fragment to implement a comparison on fields in a JSON document
|
|
[<CompiledName "WhereByFields">]
|
|
let whereByFields (howMatched: FieldMatch) fields =
|
|
let name = ParameterName()
|
|
let isNumeric (it: obj) =
|
|
match it with
|
|
| :? int8 | :? uint8 | :? int16 | :? uint16 | :? int | :? uint32 | :? int64 | :? uint64
|
|
| :? decimal | :? single | :? double -> true
|
|
| _ -> false
|
|
fields
|
|
|> Seq.map (fun it ->
|
|
match it.Comparison with
|
|
| Exists | NotExists -> $"{it.Path PostgreSQL AsSql} {it.Comparison.OpSql}"
|
|
| InArray _ -> $"{it.Path PostgreSQL AsJson} {it.Comparison.OpSql} {name.Derive it.ParameterName}"
|
|
| _ ->
|
|
let p = name.Derive it.ParameterName
|
|
let param, value =
|
|
match it.Comparison with
|
|
| Between (min, _) -> $"{p}min AND {p}max", min
|
|
| In values ->
|
|
let paramNames = values |> Seq.mapi (fun idx _ -> $"{p}_{idx}") |> String.concat ", "
|
|
$"({paramNames})", defaultArg (Seq.tryHead values) (obj ())
|
|
| Equal v | Greater v | GreaterOrEqual v | Less v | LessOrEqual v | NotEqual v -> p, v
|
|
| _ -> p, ""
|
|
if isNumeric value then
|
|
$"({it.Path PostgreSQL AsSql})::numeric {it.Comparison.OpSql} {param}"
|
|
else $"{it.Path PostgreSQL AsSql} {it.Comparison.OpSql} {param}")
|
|
|> String.concat $" {howMatched} "
|
|
|
|
/// Create a WHERE clause fragment to implement an ID-based query
|
|
[<CompiledName "WhereById">]
|
|
let whereById<'TKey> (docId: 'TKey) =
|
|
whereByFields Any [ { Field.Equal (Configuration.idField ()) docId with ParameterName = Some "@id" } ]
|
|
|
|
/// Table and index definition queries
|
|
module Definition =
|
|
|
|
/// SQL statement to create a document table
|
|
[<CompiledName "EnsureTable">]
|
|
let ensureTable name =
|
|
Query.Definition.ensureTableFor name "JSONB"
|
|
|
|
/// SQL statement to create an index on JSON documents in the specified table
|
|
[<CompiledName "EnsureDocumentIndex">]
|
|
let ensureDocumentIndex (name: string) idxType =
|
|
let extraOps = match idxType with Full -> "" | Optimized -> " jsonb_path_ops"
|
|
let tableName = name.Split '.' |> Array.last
|
|
$"CREATE INDEX IF NOT EXISTS idx_{tableName}_document ON {name} USING GIN (data{extraOps})"
|
|
|
|
/// Create a WHERE clause fragment to implement a @> (JSON contains) condition
|
|
[<CompiledName "WhereDataContains">]
|
|
let whereDataContains paramName =
|
|
$"data @> %s{paramName}"
|
|
|
|
/// Create a WHERE clause fragment to implement a @? (JSON Path match) condition
|
|
[<CompiledName "WhereJsonPathMatches">]
|
|
let whereJsonPathMatches paramName =
|
|
$"data @? %s{paramName}::jsonpath"
|
|
|
|
/// Create an UPDATE statement to patch documents
|
|
[<CompiledName "Patch">]
|
|
let patch tableName =
|
|
$"UPDATE %s{tableName} SET data = data || @data"
|
|
|
|
/// Create an UPDATE statement to remove fields from documents
|
|
[<CompiledName "RemoveFields">]
|
|
let removeFields tableName =
|
|
$"UPDATE %s{tableName} SET data = data - @name"
|
|
|
|
/// Create a query by a document's ID
|
|
[<CompiledName "ById">]
|
|
let byId<'TKey> statement (docId: 'TKey) =
|
|
Query.statementWhere statement (whereById docId)
|
|
|
|
/// Create a query on JSON fields
|
|
[<CompiledName "ByFields">]
|
|
let byFields statement howMatched fields =
|
|
Query.statementWhere statement (whereByFields howMatched fields)
|
|
|
|
/// Create a JSON containment query
|
|
[<CompiledName "ByContains">]
|
|
let byContains statement =
|
|
Query.statementWhere statement (whereDataContains "@criteria")
|
|
|
|
/// Create a JSON Path match query
|
|
[<CompiledName "ByPathMatch">]
|
|
let byPathMatch statement =
|
|
Query.statementWhere statement (whereJsonPathMatches "@path")
|
|
|
|
|
|
/// Functions for dealing with results
|
|
[<AutoOpen>]
|
|
module Results =
|
|
|
|
/// Create a domain item from a document, specifying the field in which the document is found
|
|
[<CompiledName "FromDocument">]
|
|
let fromDocument<'T> field (row: RowReader) : 'T =
|
|
Configuration.serializer().Deserialize<'T>(row.string field)
|
|
|
|
/// Create a domain item from a document
|
|
[<CompiledName "FromData">]
|
|
let fromData<'T> row : 'T =
|
|
fromDocument "data" row
|
|
|
|
/// Extract a count from the column "it"
|
|
[<CompiledName "ToCount">]
|
|
let toCount (row: RowReader) =
|
|
row.int "it"
|
|
|
|
/// Extract a true/false value from the column "it"
|
|
[<CompiledName "ToExists">]
|
|
let toExists (row: RowReader) =
|
|
row.bool "it"
|
|
|
|
|
|
/// Versions of queries that accept SqlProps as the last parameter
|
|
module WithProps =
|
|
|
|
module FSharpList = Microsoft.FSharp.Collections.List
|
|
|
|
/// Commands to execute custom SQL queries
|
|
[<RequireQualifiedAccess>]
|
|
module Custom =
|
|
|
|
/// Execute a query that returns a list of results
|
|
[<CompiledName "FSharpList">]
|
|
let list<'TDoc> query parameters (mapFunc: RowReader -> 'TDoc) sqlProps =
|
|
Sql.query query sqlProps
|
|
|> Sql.parameters (List.ofSeq parameters)
|
|
|> Sql.executeAsync mapFunc
|
|
|
|
/// Execute a query that returns a list of results
|
|
let List<'TDoc>(query, parameters, mapFunc: System.Func<RowReader, 'TDoc>, sqlProps) = backgroundTask {
|
|
let! results = list<'TDoc> query parameters mapFunc.Invoke sqlProps
|
|
return ResizeArray results
|
|
}
|
|
|
|
/// Execute a query that returns one or no results; returns None if not found
|
|
[<CompiledName "FSharpSingle">]
|
|
let single<'TDoc> query parameters mapFunc sqlProps = backgroundTask {
|
|
let! results = list<'TDoc> query parameters mapFunc sqlProps
|
|
return FSharp.Collections.List.tryHead results
|
|
}
|
|
|
|
/// Execute a query that returns one or no results; returns null if not found
|
|
let Single<'TDoc when 'TDoc: null and 'TDoc: not struct>(
|
|
query, parameters, mapFunc: System.Func<RowReader, 'TDoc>, sqlProps) = backgroundTask {
|
|
let! result = single<'TDoc> query parameters mapFunc.Invoke sqlProps
|
|
return Option.toObj result
|
|
}
|
|
|
|
/// Execute a query that returns no results
|
|
[<CompiledName "NonQuery">]
|
|
let nonQuery query parameters sqlProps =
|
|
Sql.query query sqlProps
|
|
|> Sql.parameters (FSharpList.ofSeq parameters)
|
|
|> Sql.executeNonQueryAsync
|
|
|> ignoreTask
|
|
|
|
/// Execute a query that returns a scalar value
|
|
[<CompiledName "FSharpScalar">]
|
|
let scalar<'T when 'T: struct> query parameters (mapFunc: RowReader -> 'T) sqlProps =
|
|
Sql.query query sqlProps
|
|
|> Sql.parameters (FSharpList.ofSeq parameters)
|
|
|> Sql.executeRowAsync mapFunc
|
|
|
|
/// Execute a query that returns a scalar value
|
|
let Scalar<'T when 'T: struct>(query, parameters, mapFunc: System.Func<RowReader, 'T>, sqlProps) =
|
|
scalar<'T> query parameters mapFunc.Invoke sqlProps
|
|
|
|
/// Table and index definition commands
|
|
module Definition =
|
|
|
|
/// Create a document table
|
|
[<CompiledName "EnsureTable">]
|
|
let ensureTable name sqlProps = backgroundTask {
|
|
do! Custom.nonQuery (Query.Definition.ensureTable name) [] sqlProps
|
|
do! Custom.nonQuery (Query.Definition.ensureKey name PostgreSQL) [] sqlProps
|
|
}
|
|
|
|
/// Create an index on documents in the specified table
|
|
[<CompiledName "EnsureDocumentIndex">]
|
|
let ensureDocumentIndex name idxType sqlProps =
|
|
Custom.nonQuery (Query.Definition.ensureDocumentIndex name idxType) [] sqlProps
|
|
|
|
/// Create an index on field(s) within documents in the specified table
|
|
[<CompiledName "EnsureFieldIndex">]
|
|
let ensureFieldIndex tableName indexName fields sqlProps =
|
|
Custom.nonQuery (Query.Definition.ensureIndexOn tableName indexName fields PostgreSQL) [] sqlProps
|
|
|
|
/// Commands to add documents
|
|
[<AutoOpen>]
|
|
module Document =
|
|
|
|
/// Insert a new document
|
|
[<CompiledName "Insert">]
|
|
let insert<'TDoc> tableName (document: 'TDoc) sqlProps =
|
|
let query =
|
|
match Configuration.autoIdStrategy () with
|
|
| Disabled -> Query.insert tableName
|
|
| strategy ->
|
|
let idField = Configuration.idField ()
|
|
let dataParam =
|
|
if AutoId.NeedsAutoId strategy document idField then
|
|
match strategy with
|
|
| Number ->
|
|
$"' || (SELECT COALESCE(MAX((data->>'{idField}')::numeric), 0) + 1 FROM {tableName}) || '"
|
|
| Guid -> $"\"{AutoId.GenerateGuid()}\""
|
|
| RandomString -> $"\"{AutoId.GenerateRandomString(Configuration.idStringLength ())}\""
|
|
| Disabled -> "@data"
|
|
|> function it -> $"""@data::jsonb || ('{{"{idField}":{it}}}')::jsonb"""
|
|
else "@data"
|
|
(Query.insert tableName).Replace("@data", dataParam)
|
|
Custom.nonQuery query [ jsonParam "@data" document ] sqlProps
|
|
|
|
/// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
|
|
[<CompiledName "Save">]
|
|
let save<'TDoc> tableName (document: 'TDoc) sqlProps =
|
|
Custom.nonQuery (Query.save tableName) [ jsonParam "@data" document ] sqlProps
|
|
|
|
/// Commands to count documents
|
|
[<RequireQualifiedAccess>]
|
|
module Count =
|
|
|
|
/// Count all documents in a table
|
|
[<CompiledName "All">]
|
|
let all tableName sqlProps =
|
|
Custom.scalar (Query.count tableName) [] toCount sqlProps
|
|
|
|
/// Count matching documents using JSON field comparisons (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields sqlProps =
|
|
Custom.scalar
|
|
(Query.byFields (Query.count tableName) howMatched fields) (addFieldParams fields []) toCount sqlProps
|
|
|
|
/// Count matching documents using a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TContains) sqlProps =
|
|
Custom.scalar
|
|
(Query.byContains (Query.count tableName)) [ jsonParam "@criteria" criteria ] toCount sqlProps
|
|
|
|
/// Count matching documents using a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath sqlProps =
|
|
Custom.scalar
|
|
(Query.byPathMatch (Query.count tableName)) [ "@path", Sql.string jsonPath ] toCount sqlProps
|
|
|
|
/// Commands to determine if documents exist
|
|
[<RequireQualifiedAccess>]
|
|
module Exists =
|
|
|
|
/// Determine if a document exists for the given ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) sqlProps =
|
|
Custom.scalar (Query.exists tableName (Query.whereById docId)) [ idParam docId ] toExists sqlProps
|
|
|
|
/// Determine if a document exists using JSON field comparisons (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields sqlProps =
|
|
Custom.scalar
|
|
(Query.exists tableName (Query.whereByFields howMatched fields))
|
|
(addFieldParams fields [])
|
|
toExists
|
|
sqlProps
|
|
|
|
/// Determine if a document exists using a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TContains) sqlProps =
|
|
Custom.scalar
|
|
(Query.exists tableName (Query.whereDataContains "@criteria"))
|
|
[ jsonParam "@criteria" criteria ]
|
|
toExists
|
|
sqlProps
|
|
|
|
/// Determine if a document exists using a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath sqlProps =
|
|
Custom.scalar
|
|
(Query.exists tableName (Query.whereJsonPathMatches "@path"))
|
|
[ "@path", Sql.string jsonPath ]
|
|
toExists
|
|
sqlProps
|
|
|
|
/// Commands to determine if documents exist
|
|
[<RequireQualifiedAccess>]
|
|
module Find =
|
|
|
|
/// Retrieve all documents in the given table
|
|
[<CompiledName "FSharpAll">]
|
|
let all<'TDoc> tableName sqlProps =
|
|
Custom.list<'TDoc> (Query.find tableName) [] fromData<'TDoc> sqlProps
|
|
|
|
/// Retrieve all documents in the given table
|
|
let All<'TDoc>(tableName, sqlProps) =
|
|
Custom.List<'TDoc>(Query.find tableName, [], fromData<'TDoc>, sqlProps)
|
|
|
|
/// Retrieve all documents in the given table ordered by the given fields in the document
|
|
[<CompiledName "FSharpAllOrdered">]
|
|
let allOrdered<'TDoc> tableName orderFields sqlProps =
|
|
Custom.list<'TDoc> (Query.find tableName + Query.orderBy orderFields PostgreSQL) [] fromData<'TDoc> sqlProps
|
|
|
|
/// Retrieve all documents in the given table ordered by the given fields in the document
|
|
let AllOrdered<'TDoc>(tableName, orderFields, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.find tableName + Query.orderBy orderFields PostgreSQL, [], fromData<'TDoc>, sqlProps)
|
|
|
|
/// Retrieve a document by its ID (returns None if not found)
|
|
[<CompiledName "FSharpById">]
|
|
let byId<'TKey, 'TDoc> tableName (docId: 'TKey) sqlProps =
|
|
Custom.single (Query.byId (Query.find tableName) docId) [ idParam docId ] fromData<'TDoc> sqlProps
|
|
|
|
/// Retrieve a document by its ID (returns null if not found)
|
|
let ById<'TKey, 'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, docId: 'TKey, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
Query.byId (Query.find tableName) docId, [ idParam docId ], fromData<'TDoc>, sqlProps)
|
|
|
|
/// Retrieve documents matching JSON field comparisons (->> =)
|
|
[<CompiledName "FSharpByFields">]
|
|
let byFields<'TDoc> tableName howMatched fields sqlProps =
|
|
Custom.list<'TDoc>
|
|
(Query.byFields (Query.find tableName) howMatched fields)
|
|
(addFieldParams fields [])
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve documents matching JSON field comparisons (->> =)
|
|
let ByFields<'TDoc>(tableName, howMatched, fields, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.byFields (Query.find tableName) howMatched fields,
|
|
addFieldParams fields [],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve documents matching JSON field comparisons (->> =) ordered by the given fields in the document
|
|
[<CompiledName "FSharpByFieldsOrdered">]
|
|
let byFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields sqlProps =
|
|
Custom.list<'TDoc>
|
|
(Query.byFields (Query.find tableName) howMatched queryFields + Query.orderBy orderFields PostgreSQL)
|
|
(addFieldParams queryFields [])
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve documents matching JSON field comparisons (->> =) ordered by the given fields in the document
|
|
let ByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.byFields (Query.find tableName) howMatched queryFields + Query.orderBy orderFields PostgreSQL,
|
|
addFieldParams queryFields [],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>)
|
|
[<CompiledName "FSharpByContains">]
|
|
let byContains<'TDoc> tableName (criteria: obj) sqlProps =
|
|
Custom.list<'TDoc>
|
|
(Query.byContains (Query.find tableName)) [ jsonParam "@criteria" criteria ] fromData<'TDoc> sqlProps
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>)
|
|
let ByContains<'TDoc>(tableName, criteria: obj, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.byContains (Query.find tableName),
|
|
[ jsonParam "@criteria" criteria ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>) ordered by the given fields in the document
|
|
[<CompiledName "FSharpByContainsOrdered">]
|
|
let byContainsOrdered<'TDoc> tableName (criteria: obj) orderFields sqlProps =
|
|
Custom.list<'TDoc>
|
|
(Query.byContains (Query.find tableName) + Query.orderBy orderFields PostgreSQL)
|
|
[ jsonParam "@criteria" criteria ]
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>) ordered by the given fields in the document
|
|
let ByContainsOrdered<'TDoc>(tableName, criteria: obj, orderFields, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.byContains (Query.find tableName) + Query.orderBy orderFields PostgreSQL,
|
|
[ jsonParam "@criteria" criteria ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?)
|
|
[<CompiledName "FSharpByJsonPath">]
|
|
let byJsonPath<'TDoc> tableName jsonPath sqlProps =
|
|
Custom.list<'TDoc>
|
|
(Query.byPathMatch (Query.find tableName)) [ "@path", Sql.string jsonPath ] fromData<'TDoc> sqlProps
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?)
|
|
let ByJsonPath<'TDoc>(tableName, jsonPath, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.byPathMatch (Query.find tableName),
|
|
[ "@path", Sql.string jsonPath ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?) ordered by the given fields in the document
|
|
[<CompiledName "FSharpByJsonPathOrdered">]
|
|
let byJsonPathOrdered<'TDoc> tableName jsonPath orderFields sqlProps =
|
|
Custom.list<'TDoc>
|
|
(Query.byPathMatch (Query.find tableName) + Query.orderBy orderFields PostgreSQL)
|
|
[ "@path", Sql.string jsonPath ]
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?) ordered by the given fields in the document
|
|
let ByJsonPathOrdered<'TDoc>(tableName, jsonPath, orderFields, sqlProps) =
|
|
Custom.List<'TDoc>(
|
|
Query.byPathMatch (Query.find tableName) + Query.orderBy orderFields PostgreSQL,
|
|
[ "@path", Sql.string jsonPath ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve the first document matching JSON field comparisons (->> =); returns None if not found
|
|
[<CompiledName "FSharpFirstByFields">]
|
|
let firstByFields<'TDoc> tableName howMatched fields sqlProps =
|
|
Custom.single<'TDoc>
|
|
$"{Query.byFields (Query.find tableName) howMatched fields} LIMIT 1"
|
|
(addFieldParams fields [])
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve the first document matching JSON field comparisons (->> =); returns null if not found
|
|
let FirstByFields<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, howMatched, fields, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
$"{Query.byFields (Query.find tableName) howMatched fields} LIMIT 1",
|
|
addFieldParams fields [],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve the first document matching JSON field comparisons (->> =) ordered by the given fields in the
|
|
/// document; returns None if not found
|
|
[<CompiledName "FSharpFirstByFieldsOrdered">]
|
|
let firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields sqlProps =
|
|
Custom.single<'TDoc>
|
|
$"{Query.byFields (Query.find tableName) howMatched queryFields}{Query.orderBy orderFields PostgreSQL} LIMIT 1"
|
|
(addFieldParams queryFields [])
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve the first document matching JSON field comparisons (->> =) ordered by the given fields in the
|
|
/// document; returns null if not found
|
|
let FirstByFieldsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(
|
|
tableName, howMatched, queryFields, orderFields, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
$"{Query.byFields (Query.find tableName) howMatched queryFields}{Query.orderBy orderFields PostgreSQL} LIMIT 1",
|
|
addFieldParams queryFields [],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>); returns None if not found
|
|
[<CompiledName "FSharpFirstByContains">]
|
|
let firstByContains<'TDoc> tableName (criteria: obj) sqlProps =
|
|
Custom.single<'TDoc>
|
|
$"{Query.byContains (Query.find tableName)} LIMIT 1"
|
|
[ jsonParam "@criteria" criteria ]
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>); returns null if not found
|
|
let FirstByContains<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, criteria: obj, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
$"{Query.byContains (Query.find tableName)} LIMIT 1",
|
|
[ jsonParam "@criteria" criteria ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>) ordered by the given fields in the
|
|
/// document; returns None if not found
|
|
[<CompiledName "FSharpFirstByContainsOrdered">]
|
|
let firstByContainsOrdered<'TDoc> tableName (criteria: obj) orderFields sqlProps =
|
|
Custom.single<'TDoc>
|
|
$"{Query.byContains (Query.find tableName)}{Query.orderBy orderFields PostgreSQL} LIMIT 1"
|
|
[ jsonParam "@criteria" criteria ]
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>) ordered by the given fields in the
|
|
/// document; returns null if not found
|
|
let FirstByContainsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(
|
|
tableName, criteria: obj, orderFields, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
$"{Query.byContains (Query.find tableName)}{Query.orderBy orderFields PostgreSQL} LIMIT 1",
|
|
[ jsonParam "@criteria" criteria ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?); returns None if not found
|
|
[<CompiledName "FSharpFirstByJsonPath">]
|
|
let firstByJsonPath<'TDoc> tableName jsonPath sqlProps =
|
|
Custom.single<'TDoc>
|
|
$"{Query.byPathMatch (Query.find tableName)} LIMIT 1"
|
|
[ "@path", Sql.string jsonPath ]
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?); returns null if not found
|
|
let FirstByJsonPath<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, jsonPath, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
$"{Query.byPathMatch (Query.find tableName)} LIMIT 1",
|
|
[ "@path", Sql.string jsonPath ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?) ordered by the given fields in the
|
|
/// document; returns None if not found
|
|
[<CompiledName "FSharpFirstByJsonPathOrdered">]
|
|
let firstByJsonPathOrdered<'TDoc> tableName jsonPath orderFields sqlProps =
|
|
Custom.single<'TDoc>
|
|
$"{Query.byPathMatch (Query.find tableName)}{Query.orderBy orderFields PostgreSQL} LIMIT 1"
|
|
[ "@path", Sql.string jsonPath ]
|
|
fromData<'TDoc>
|
|
sqlProps
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?) ordered by the given fields in the
|
|
/// document; returns null if not found
|
|
let FirstByJsonPathOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(
|
|
tableName, jsonPath, orderFields, sqlProps) =
|
|
Custom.Single<'TDoc>(
|
|
$"{Query.byPathMatch (Query.find tableName)}{Query.orderBy orderFields PostgreSQL} LIMIT 1",
|
|
[ "@path", Sql.string jsonPath ],
|
|
fromData<'TDoc>,
|
|
sqlProps)
|
|
|
|
/// Commands to update documents
|
|
[<RequireQualifiedAccess>]
|
|
module Update =
|
|
|
|
/// Update an entire document by its ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) (document: 'TDoc) sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byId (Query.update tableName) docId) [ idParam docId; jsonParam "@data" document ] sqlProps
|
|
|
|
/// Update an entire document by its ID, using the provided function to obtain the ID from the document
|
|
[<CompiledName "FSharpByFunc">]
|
|
let byFunc tableName (idFunc: 'TDoc -> 'TKey) (document: 'TDoc) sqlProps =
|
|
byId tableName (idFunc document) document sqlProps
|
|
|
|
/// Update an entire document by its ID, using the provided function to obtain the ID from the document
|
|
let ByFunc(tableName, idFunc: System.Func<'TDoc, 'TKey>, document: 'TDoc, sqlProps) =
|
|
byFunc tableName idFunc.Invoke document sqlProps
|
|
|
|
/// Commands to patch (partially update) documents
|
|
[<RequireQualifiedAccess>]
|
|
module Patch =
|
|
|
|
/// Patch a document by its ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) (patch: 'TPatch) sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byId (Query.patch tableName) docId) [ idParam docId; jsonParam "@data" patch ] sqlProps
|
|
|
|
/// Patch documents using a JSON field comparison query in the WHERE clause (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields (patch: 'TPatch) sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byFields (Query.patch tableName) howMatched fields)
|
|
(addFieldParams fields [ jsonParam "@data" patch ])
|
|
sqlProps
|
|
|
|
/// Patch documents using a JSON containment query in the WHERE clause (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TContains) (patch: 'TPatch) sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byContains (Query.patch tableName))
|
|
[ jsonParam "@data" patch; jsonParam "@criteria" criteria ]
|
|
sqlProps
|
|
|
|
/// Patch documents using a JSON Path match query in the WHERE clause (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath (patch: 'TPatch) sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byPathMatch (Query.patch tableName))
|
|
[ jsonParam "@data" patch; "@path", Sql.string jsonPath ]
|
|
sqlProps
|
|
|
|
/// Commands to remove fields from documents
|
|
[<RequireQualifiedAccess>]
|
|
module RemoveFields =
|
|
|
|
/// Remove fields from a document by the document's ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) fieldNames sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byId (Query.removeFields tableName) docId) [ idParam docId; fieldNameParams fieldNames ] sqlProps
|
|
|
|
/// Remove fields from documents via a comparison on JSON fields in the document
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields fieldNames sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byFields (Query.removeFields tableName) howMatched fields)
|
|
(addFieldParams fields [ fieldNameParams fieldNames ])
|
|
sqlProps
|
|
|
|
/// Remove fields from documents via a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TContains) fieldNames sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byContains (Query.removeFields tableName))
|
|
[ jsonParam "@criteria" criteria; fieldNameParams fieldNames ]
|
|
sqlProps
|
|
|
|
/// Remove fields from documents via a JSON Path match query (@?)
|
|
[<CompiledName "FSharpByJsonPath">]
|
|
let byJsonPath tableName jsonPath fieldNames sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byPathMatch (Query.removeFields tableName))
|
|
[ "@path", Sql.string jsonPath; fieldNameParams fieldNames ]
|
|
sqlProps
|
|
|
|
/// Commands to delete documents
|
|
[<RequireQualifiedAccess>]
|
|
module Delete =
|
|
|
|
/// Delete a document by its ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) sqlProps =
|
|
Custom.nonQuery (Query.byId (Query.delete tableName) docId) [ idParam docId ] sqlProps
|
|
|
|
/// Delete documents by matching a JSON field comparison query (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields sqlProps =
|
|
Custom.nonQuery
|
|
(Query.byFields (Query.delete tableName) howMatched fields) (addFieldParams fields []) sqlProps
|
|
|
|
/// Delete documents by matching a JSON contains query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TCriteria) sqlProps =
|
|
Custom.nonQuery (Query.byContains (Query.delete tableName)) [ jsonParam "@criteria" criteria ] sqlProps
|
|
|
|
/// Delete documents by matching a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName path sqlProps =
|
|
Custom.nonQuery (Query.byPathMatch (Query.delete tableName)) [ "@path", Sql.string path ] sqlProps
|
|
|
|
|
|
/// Commands to execute custom SQL queries
|
|
[<RequireQualifiedAccess>]
|
|
module Custom =
|
|
|
|
/// Execute a query that returns a list of results
|
|
[<CompiledName "FSharpList">]
|
|
let list<'TDoc> query parameters (mapFunc: RowReader -> 'TDoc) =
|
|
WithProps.Custom.list<'TDoc> query parameters mapFunc (fromDataSource ())
|
|
|
|
/// Execute a query that returns a list of results
|
|
let List<'TDoc>(query, parameters, mapFunc: System.Func<RowReader, 'TDoc>) =
|
|
WithProps.Custom.List<'TDoc>(query, parameters, mapFunc, fromDataSource ())
|
|
|
|
/// Execute a query that returns one or no results; returns None if not found
|
|
[<CompiledName "FSharpSingle">]
|
|
let single<'TDoc> query parameters (mapFunc: RowReader -> 'TDoc) =
|
|
WithProps.Custom.single<'TDoc> query parameters mapFunc (fromDataSource ())
|
|
|
|
/// Execute a query that returns one or no results; returns null if not found
|
|
let Single<'TDoc when 'TDoc: null and 'TDoc: not struct>(
|
|
query, parameters, mapFunc: System.Func<RowReader, 'TDoc>) =
|
|
WithProps.Custom.Single<'TDoc>(query, parameters, mapFunc, fromDataSource ())
|
|
|
|
/// Execute a query that returns no results
|
|
[<CompiledName "NonQuery">]
|
|
let nonQuery query parameters =
|
|
WithProps.Custom.nonQuery query parameters (fromDataSource ())
|
|
|
|
/// Execute a query that returns a scalar value
|
|
[<CompiledName "FSharpScalar">]
|
|
let scalar<'T when 'T: struct> query parameters (mapFunc: RowReader -> 'T) =
|
|
WithProps.Custom.scalar query parameters mapFunc (fromDataSource ())
|
|
|
|
/// Execute a query that returns a scalar value
|
|
let Scalar<'T when 'T: struct>(query, parameters, mapFunc: System.Func<RowReader, 'T>) =
|
|
WithProps.Custom.Scalar<'T>(query, parameters, mapFunc, fromDataSource ())
|
|
|
|
|
|
/// Table and index definition commands
|
|
[<RequireQualifiedAccess>]
|
|
module Definition =
|
|
|
|
/// Create a document table
|
|
[<CompiledName "EnsureTable">]
|
|
let ensureTable name =
|
|
WithProps.Definition.ensureTable name (fromDataSource ())
|
|
|
|
/// Create an index on documents in the specified table
|
|
[<CompiledName "EnsureDocumentIndex">]
|
|
let ensureDocumentIndex name idxType =
|
|
WithProps.Definition.ensureDocumentIndex name idxType (fromDataSource ())
|
|
|
|
/// Create an index on field(s) within documents in the specified table
|
|
[<CompiledName "EnsureFieldIndex">]
|
|
let ensureFieldIndex tableName indexName fields =
|
|
WithProps.Definition.ensureFieldIndex tableName indexName fields (fromDataSource ())
|
|
|
|
|
|
/// Document writing functions
|
|
[<AutoOpen>]
|
|
module Document =
|
|
|
|
/// Insert a new document
|
|
[<CompiledName "Insert">]
|
|
let insert<'TDoc> tableName (document: 'TDoc) =
|
|
WithProps.Document.insert<'TDoc> tableName document (fromDataSource ())
|
|
|
|
/// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
|
|
[<CompiledName "Save">]
|
|
let save<'TDoc> tableName (document: 'TDoc) =
|
|
WithProps.Document.save<'TDoc> tableName document (fromDataSource ())
|
|
|
|
|
|
/// Queries to count documents
|
|
[<RequireQualifiedAccess>]
|
|
module Count =
|
|
|
|
/// Count all documents in a table
|
|
[<CompiledName "All">]
|
|
let all tableName =
|
|
WithProps.Count.all tableName (fromDataSource ())
|
|
|
|
/// Count matching documents using a JSON field comparison query (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields =
|
|
WithProps.Count.byFields tableName howMatched fields (fromDataSource ())
|
|
|
|
/// Count matching documents using a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName criteria =
|
|
WithProps.Count.byContains tableName criteria (fromDataSource ())
|
|
|
|
/// Count matching documents using a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath =
|
|
WithProps.Count.byJsonPath tableName jsonPath (fromDataSource ())
|
|
|
|
|
|
/// Queries to determine if documents exist
|
|
[<RequireQualifiedAccess>]
|
|
module Exists =
|
|
|
|
/// Determine if a document exists for the given ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName docId =
|
|
WithProps.Exists.byId tableName docId (fromDataSource ())
|
|
|
|
/// Determine if documents exist using a JSON field comparison query (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields =
|
|
WithProps.Exists.byFields tableName howMatched fields (fromDataSource ())
|
|
|
|
/// Determine if documents exist using a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName criteria =
|
|
WithProps.Exists.byContains tableName criteria (fromDataSource ())
|
|
|
|
/// Determine if documents exist using a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath =
|
|
WithProps.Exists.byJsonPath tableName jsonPath (fromDataSource ())
|
|
|
|
|
|
/// Commands to retrieve documents
|
|
[<RequireQualifiedAccess>]
|
|
module Find =
|
|
|
|
/// Retrieve all documents in the given table
|
|
[<CompiledName "FSharpAll">]
|
|
let all<'TDoc> tableName =
|
|
WithProps.Find.all<'TDoc> tableName (fromDataSource ())
|
|
|
|
/// Retrieve all documents in the given table
|
|
let All<'TDoc> tableName =
|
|
WithProps.Find.All<'TDoc>(tableName, fromDataSource ())
|
|
|
|
/// Retrieve all documents in the given table ordered by the given fields in the document
|
|
[<CompiledName "FSharpAllOrdered">]
|
|
let allOrdered<'TDoc> tableName orderFields =
|
|
WithProps.Find.allOrdered<'TDoc> tableName orderFields (fromDataSource ())
|
|
|
|
/// Retrieve all documents in the given table ordered by the given fields in the document
|
|
let AllOrdered<'TDoc> tableName orderFields =
|
|
WithProps.Find.AllOrdered<'TDoc>(tableName, orderFields, fromDataSource ())
|
|
|
|
/// Retrieve a document by its ID; returns None if not found
|
|
[<CompiledName "FSharpById">]
|
|
let byId<'TKey, 'TDoc> tableName docId =
|
|
WithProps.Find.byId<'TKey, 'TDoc> tableName docId (fromDataSource ())
|
|
|
|
/// Retrieve a document by its ID; returns null if not found
|
|
let ById<'TKey, 'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, docId: 'TKey) =
|
|
WithProps.Find.ById<'TKey, 'TDoc>(tableName, docId, fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON field comparison query (->> =)
|
|
[<CompiledName "FSharpByFields">]
|
|
let byFields<'TDoc> tableName howMatched fields =
|
|
WithProps.Find.byFields<'TDoc> tableName howMatched fields (fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON field comparison query (->> =)
|
|
let ByFields<'TDoc>(tableName, howMatched, fields) =
|
|
WithProps.Find.ByFields<'TDoc>(tableName, howMatched, fields, fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON field comparison query (->> =) ordered by the given fields in the document
|
|
[<CompiledName "FSharpByFieldsOrdered">]
|
|
let byFieldsOrdered<'TDoc> tableName howMatched queryField orderFields =
|
|
WithProps.Find.byFieldsOrdered<'TDoc> tableName howMatched queryField orderFields (fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON field comparison query (->> =) ordered by the given fields in the document
|
|
let ByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields) =
|
|
WithProps.Find.ByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>)
|
|
[<CompiledName "FSharpByContains">]
|
|
let byContains<'TDoc> tableName (criteria: obj) =
|
|
WithProps.Find.byContains<'TDoc> tableName criteria (fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>)
|
|
let ByContains<'TDoc>(tableName, criteria: obj) =
|
|
WithProps.Find.ByContains<'TDoc>(tableName, criteria, fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>) ordered by the given fields in the document
|
|
[<CompiledName "FSharpByContainsOrdered">]
|
|
let byContainsOrdered<'TDoc> tableName (criteria: obj) orderFields =
|
|
WithProps.Find.byContainsOrdered<'TDoc> tableName criteria orderFields (fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON containment query (@>) ordered by the given fields in the document
|
|
let ByContainsOrdered<'TDoc>(tableName, criteria: obj, orderFields) =
|
|
WithProps.Find.ByContainsOrdered<'TDoc>(tableName, criteria, orderFields, fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?)
|
|
[<CompiledName "FSharpByJsonPath">]
|
|
let byJsonPath<'TDoc> tableName jsonPath =
|
|
WithProps.Find.byJsonPath<'TDoc> tableName jsonPath (fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?)
|
|
let ByJsonPath<'TDoc>(tableName, jsonPath) =
|
|
WithProps.Find.ByJsonPath<'TDoc>(tableName, jsonPath, fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?) ordered by the given fields in the document
|
|
[<CompiledName "FSharpByJsonPathOrdered">]
|
|
let byJsonPathOrdered<'TDoc> tableName jsonPath orderFields =
|
|
WithProps.Find.byJsonPathOrdered<'TDoc> tableName jsonPath orderFields (fromDataSource ())
|
|
|
|
/// Retrieve documents matching a JSON Path match query (@?) ordered by the given fields in the document
|
|
let ByJsonPathOrdered<'TDoc>(tableName, jsonPath, orderFields) =
|
|
WithProps.Find.ByJsonPathOrdered<'TDoc>(tableName, jsonPath, orderFields, fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON field comparison query (->> =); returns None if not found
|
|
[<CompiledName "FSharpFirstByFields">]
|
|
let firstByFields<'TDoc> tableName howMatched fields =
|
|
WithProps.Find.firstByFields<'TDoc> tableName howMatched fields (fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON field comparison query (->> =); returns null if not found
|
|
let FirstByFields<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, howMatched, fields) =
|
|
WithProps.Find.FirstByFields<'TDoc>(tableName, howMatched, fields, fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON field comparison query (->> =) ordered by the given fields in the
|
|
/// document; returns None if not found
|
|
[<CompiledName "FSharpFirstByFieldsOrdered">]
|
|
let firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields =
|
|
WithProps.Find.firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields (fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON field comparison query (->> =) ordered by the given fields in the
|
|
/// document; returns null if not found
|
|
let FirstByFieldsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(
|
|
tableName, howMatched, queryFields, orderFields) =
|
|
WithProps.Find.FirstByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>); returns None if not found
|
|
[<CompiledName "FSharpFirstByContains">]
|
|
let firstByContains<'TDoc> tableName (criteria: obj) =
|
|
WithProps.Find.firstByContains<'TDoc> tableName criteria (fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>); returns null if not found
|
|
let FirstByContains<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, criteria: obj) =
|
|
WithProps.Find.FirstByContains<'TDoc>(tableName, criteria, fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>) ordered by the given fields in the document;
|
|
/// returns None if not found
|
|
[<CompiledName "FSharpFirstByContainsOrdered">]
|
|
let firstByContainsOrdered<'TDoc> tableName (criteria: obj) orderFields =
|
|
WithProps.Find.firstByContainsOrdered<'TDoc> tableName criteria orderFields (fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON containment query (@>) ordered by the given fields in the document;
|
|
/// returns null if not found
|
|
let FirstByContainsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, criteria: obj, orderFields) =
|
|
WithProps.Find.FirstByContainsOrdered<'TDoc>(tableName, criteria, orderFields, fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?); returns None if not found
|
|
[<CompiledName "FSharpFirstByJsonPath">]
|
|
let firstByJsonPath<'TDoc> tableName jsonPath =
|
|
WithProps.Find.firstByJsonPath<'TDoc> tableName jsonPath (fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?); returns null if not found
|
|
let FirstByJsonPath<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, jsonPath) =
|
|
WithProps.Find.FirstByJsonPath<'TDoc>(tableName, jsonPath, fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?) ordered by the given fields in the document;
|
|
/// returns None if not found
|
|
[<CompiledName "FSharpFirstByJsonPathOrdered">]
|
|
let firstByJsonPathOrdered<'TDoc> tableName jsonPath orderFields =
|
|
WithProps.Find.firstByJsonPathOrdered<'TDoc> tableName jsonPath orderFields (fromDataSource ())
|
|
|
|
/// Retrieve the first document matching a JSON Path match query (@?) ordered by the given fields in the document;
|
|
/// returns null if not found
|
|
let FirstByJsonPathOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, jsonPath, orderFields) =
|
|
WithProps.Find.FirstByJsonPathOrdered<'TDoc>(tableName, jsonPath, orderFields, fromDataSource ())
|
|
|
|
|
|
/// Commands to update documents
|
|
[<RequireQualifiedAccess>]
|
|
module Update =
|
|
|
|
/// Update an entire document by its ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) (document: 'TDoc) =
|
|
WithProps.Update.byId tableName docId document (fromDataSource ())
|
|
|
|
/// Update an entire document by its ID, using the provided function to obtain the ID from the document
|
|
[<CompiledName "FSharpFullFunc">]
|
|
let byFunc tableName (idFunc: 'TDoc -> 'TKey) (document: 'TDoc) =
|
|
WithProps.Update.byFunc tableName idFunc document (fromDataSource ())
|
|
|
|
/// Update an entire document by its ID, using the provided function to obtain the ID from the document
|
|
let ByFunc(tableName, idFunc: System.Func<'TDoc, 'TKey>, document: 'TDoc) =
|
|
WithProps.Update.ByFunc(tableName, idFunc, document, fromDataSource ())
|
|
|
|
|
|
/// Commands to patch (partially update) documents
|
|
[<RequireQualifiedAccess>]
|
|
module Patch =
|
|
|
|
/// Patch a document by its ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) (patch: 'TPatch) =
|
|
WithProps.Patch.byId tableName docId patch (fromDataSource ())
|
|
|
|
/// Patch documents using a JSON field comparison query in the WHERE clause (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields (patch: 'TPatch) =
|
|
WithProps.Patch.byFields tableName howMatched fields patch (fromDataSource ())
|
|
|
|
/// Patch documents using a JSON containment query in the WHERE clause (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TCriteria) (patch: 'TPatch) =
|
|
WithProps.Patch.byContains tableName criteria patch (fromDataSource ())
|
|
|
|
/// Patch documents using a JSON Path match query in the WHERE clause (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath (patch: 'TPatch) =
|
|
WithProps.Patch.byJsonPath tableName jsonPath patch (fromDataSource ())
|
|
|
|
|
|
/// Commands to remove fields from documents
|
|
[<RequireQualifiedAccess>]
|
|
module RemoveFields =
|
|
|
|
/// Remove fields from a document by the document's ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) fieldNames =
|
|
WithProps.RemoveFields.byId tableName docId fieldNames (fromDataSource ())
|
|
|
|
/// Remove fields from documents via a comparison on JSON fields in the document
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields fieldNames =
|
|
WithProps.RemoveFields.byFields tableName howMatched fields fieldNames (fromDataSource ())
|
|
|
|
/// Remove fields from documents via a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TContains) fieldNames =
|
|
WithProps.RemoveFields.byContains tableName criteria fieldNames (fromDataSource ())
|
|
|
|
/// Remove fields from documents via a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName jsonPath fieldNames =
|
|
WithProps.RemoveFields.byJsonPath tableName jsonPath fieldNames (fromDataSource ())
|
|
|
|
|
|
/// Commands to delete documents
|
|
[<RequireQualifiedAccess>]
|
|
module Delete =
|
|
|
|
/// Delete a document by its ID
|
|
[<CompiledName "ById">]
|
|
let byId tableName (docId: 'TKey) =
|
|
WithProps.Delete.byId tableName docId (fromDataSource ())
|
|
|
|
/// Delete documents by matching a JSON field comparison query (->> =)
|
|
[<CompiledName "ByFields">]
|
|
let byFields tableName howMatched fields =
|
|
WithProps.Delete.byFields tableName howMatched fields (fromDataSource ())
|
|
|
|
/// Delete documents by matching a JSON containment query (@>)
|
|
[<CompiledName "ByContains">]
|
|
let byContains tableName (criteria: 'TContains) =
|
|
WithProps.Delete.byContains tableName criteria (fromDataSource ())
|
|
|
|
/// Delete documents by matching a JSON Path match query (@?)
|
|
[<CompiledName "ByJsonPath">]
|
|
let byJsonPath tableName path =
|
|
WithProps.Delete.byJsonPath tableName path (fromDataSource ())
|