Daniel J. Summers
5580284910
The prior `///` F# documentation blocks were not rendering in IDEs, and parameters were not documented. This change adds complete XML documentation to all (but `Compat`) classes, methods, and functions. Reviewed-on: #10
634 lines
29 KiB
Forth
634 lines
29 KiB
Forth
namespace BitBadger.Documents
|
|
|
|
open System.Security.Cryptography
|
|
|
|
/// <summary>The types of comparisons available for JSON fields</summary>
|
|
/// <exclude />
|
|
type Comparison =
|
|
|
|
/// <summary>Equals (<tt>=</tt>)</summary>
|
|
| Equal of Value: obj
|
|
|
|
/// <summary>Greater Than (<tt>></tt>)</summary>
|
|
| Greater of Value: obj
|
|
|
|
/// <summary>Greater Than or Equal To (<tt>>=</tt>)</summary>
|
|
| GreaterOrEqual of Value: obj
|
|
|
|
/// <summary>Less Than (<tt><</tt>)</summary>
|
|
| Less of Value: obj
|
|
|
|
/// <summary>Less Than or Equal To (<tt><=</tt>)</summary>
|
|
| LessOrEqual of Value: obj
|
|
|
|
/// <summary>Not Equal to (<tt><></tt>)</summary>
|
|
| NotEqual of Value: obj
|
|
|
|
/// <summary>Between (<tt>BETWEEN</tt>)</summary>
|
|
| Between of Min: obj * Max: obj
|
|
|
|
/// <summary>In (<tt>IN</tt>)</summary>
|
|
| In of Values: obj seq
|
|
|
|
/// <summary>In Array (PostgreSQL: <tt>|?</tt>, SQLite: <tt>EXISTS / json_each / IN</tt>)</summary>
|
|
| InArray of Table: string * Values: obj seq
|
|
|
|
/// <summary>Exists (<tt>IS NOT NULL</tt>)</summary>
|
|
| Exists
|
|
|
|
/// <summary>Does Not Exist (<tt>IS NULL</tt>)</summary>
|
|
| NotExists
|
|
|
|
/// <summary>The operator SQL for this comparison</summary>
|
|
member this.OpSql =
|
|
match this with
|
|
| Equal _ -> "="
|
|
| Greater _ -> ">"
|
|
| GreaterOrEqual _ -> ">="
|
|
| Less _ -> "<"
|
|
| LessOrEqual _ -> "<="
|
|
| NotEqual _ -> "<>"
|
|
| Between _ -> "BETWEEN"
|
|
| In _ -> "IN"
|
|
| InArray _ -> "?|" // PostgreSQL only; SQL needs a subquery for this
|
|
| Exists -> "IS NOT NULL"
|
|
| NotExists -> "IS NULL"
|
|
|
|
|
|
/// <summary>The dialect in which a command should be rendered</summary>
|
|
[<Struct>]
|
|
type Dialect =
|
|
| PostgreSQL
|
|
| SQLite
|
|
|
|
|
|
/// <summary>The format in which an element of a JSON field should be extracted</summary>
|
|
[<Struct>]
|
|
type FieldFormat =
|
|
|
|
/// <summary>
|
|
/// Use <tt>->></tt> or <tt>#>></tt>; extracts a text (PostgreSQL) or SQL (SQLite) value
|
|
/// </summary>
|
|
| AsSql
|
|
|
|
/// <summary>Use <tt>-></tt> or <tt>#></tt>; extracts a JSONB (PostgreSQL) or JSON (SQLite) value</summary>
|
|
| AsJson
|
|
|
|
|
|
/// <summary>Criteria for a field <tt>WHERE</tt> clause</summary>
|
|
type Field = {
|
|
|
|
/// <summary>The name of the field</summary>
|
|
Name: string
|
|
|
|
/// <summary>The comparison for the field</summary>
|
|
Comparison: Comparison
|
|
|
|
/// <summary>The name of the parameter for this field</summary>
|
|
ParameterName: string option
|
|
|
|
/// <summary>The table qualifier for this field</summary>
|
|
Qualifier: string option
|
|
} with
|
|
|
|
/// <summary>Create a comparison against a field</summary>
|
|
/// <param name="name">The name of the field against which the comparison should be applied</param>
|
|
/// <param name="comparison">The comparison for the given field</param>
|
|
/// <returns>A new <tt>Field</tt> instance implementing the given comparison</returns>
|
|
static member Where name (comparison: Comparison) =
|
|
{ Name = name; Comparison = comparison; ParameterName = None; Qualifier = None }
|
|
|
|
/// <summary>Create an equals (<tt>=</tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member Equal<'T> name (value: 'T) =
|
|
Field.Where name (Equal value)
|
|
|
|
/// <summary>Create an equals (<tt>=</tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member EQ<'T> name (value: 'T) = Field.Equal name value
|
|
|
|
/// <summary>Create a greater than (<tt>></tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member Greater<'T> name (value: 'T) =
|
|
Field.Where name (Greater value)
|
|
|
|
/// <summary>Create a greater than (<tt>></tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member GT<'T> name (value: 'T) = Field.Greater name value
|
|
|
|
/// <summary>Create a greater than or equal to (<tt>>=</tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member GreaterOrEqual<'T> name (value: 'T) =
|
|
Field.Where name (GreaterOrEqual value)
|
|
|
|
/// <summary>Create a greater than or equal to (<tt>>=</tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member GE<'T> name (value: 'T) = Field.GreaterOrEqual name value
|
|
|
|
/// <summary>Create a less than (<tt><</tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member Less<'T> name (value: 'T) =
|
|
Field.Where name (Less value)
|
|
|
|
/// <summary>Create a less than (<tt><</tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member LT<'T> name (value: 'T) = Field.Less name value
|
|
|
|
/// <summary>Create a less than or equal to (<tt><=</tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member LessOrEqual<'T> name (value: 'T) =
|
|
Field.Where name (LessOrEqual value)
|
|
|
|
/// <summary>Create a less than or equal to (<tt><=</tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member LE<'T> name (value: 'T) = Field.LessOrEqual name value
|
|
|
|
/// <summary>Create a not equals (<tt><></tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member NotEqual<'T> name (value: 'T) =
|
|
Field.Where name (NotEqual value)
|
|
|
|
/// <summary>Create a not equals (<tt><></tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="value">The value for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member NE<'T> name (value: 'T) = Field.NotEqual name value
|
|
|
|
/// <summary>Create a Between field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="min">The minimum value for the comparison range</param>
|
|
/// <param name="max">The maximum value for the comparison range</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member Between<'T> name (min: 'T) (max: 'T) =
|
|
Field.Where name (Between(min, max))
|
|
|
|
/// <summary>Create a Between field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="min">The minimum value for the comparison range</param>
|
|
/// <param name="max">The maximum value for the comparison range</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member BT<'T> name (min: 'T) (max: 'T) = Field.Between name min max
|
|
|
|
/// <summary>Create an In field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="values">The values for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member In<'T> name (values: 'T seq) =
|
|
Field.Where name (In (Seq.map box values))
|
|
|
|
/// <summary>Create an In field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="values">The values for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member IN<'T> name (values: 'T seq) = Field.In name values
|
|
|
|
/// <summary>Create an InArray field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <param name="tableName">The name of the table in which the field's documents are stored</param>
|
|
/// <param name="values">The values for the comparison</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member InArray<'T> name tableName (values: 'T seq) =
|
|
Field.Where name (InArray(tableName, Seq.map box values))
|
|
|
|
/// <summary>Create an exists (<tt>IS NOT NULL</tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member Exists name =
|
|
Field.Where name Exists
|
|
|
|
/// <summary>Create an exists (<tt>IS NOT NULL</tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member EX name = Field.Exists name
|
|
|
|
/// <summary>Create a not exists (<tt>IS NULL</tt>) field criterion</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member NotExists name =
|
|
Field.Where name NotExists
|
|
|
|
/// <summary>Create a not exists (<tt>IS NULL</tt>) field criterion (alias)</summary>
|
|
/// <param name="name">The name of the field to be compared</param>
|
|
/// <returns>A field with the given comparison</returns>
|
|
static member NEX name = Field.NotExists name
|
|
|
|
/// <summary>Transform a field name (<tt>a.b.c</tt>) to a path for the given SQL dialect</summary>
|
|
/// <param name="name">The name of the field in dotted format</param>
|
|
/// <param name="dialect">The SQL dialect to use when converting the name to nested path format</param>
|
|
/// <param name="format">Whether to reference this path as a JSON value or a SQL value</param>
|
|
/// <returns>A <tt>string</tt> with the path required to address the nested document value</returns>
|
|
static member NameToPath (name: string) dialect format =
|
|
let path =
|
|
if name.Contains '.' then
|
|
match dialect with
|
|
| PostgreSQL ->
|
|
(match format with AsJson -> "#>" | AsSql -> "#>>")
|
|
+ "'{" + String.concat "," (name.Split '.') + "}'"
|
|
| SQLite ->
|
|
let parts = name.Split '.'
|
|
let last = Array.last parts
|
|
let final = (match format with AsJson -> "'->'" | AsSql -> "'->>'") + $"{last}'"
|
|
"->'" + String.concat "'->'" (Array.truncate (Array.length parts - 1) parts) + final
|
|
else
|
|
match format with AsJson -> $"->'{name}'" | AsSql -> $"->>'{name}'"
|
|
$"data{path}"
|
|
|
|
/// <summary>Create a field with a given name, but no other properties filled</summary>
|
|
/// <param name="name">The field name, along with any other qualifications if used in a sorting context</param>
|
|
/// <remarks><tt>Comparison</tt> will be <tt>Equal</tt>, value will be an empty string</remarks>
|
|
static member Named name =
|
|
Field.Where name (Equal "")
|
|
|
|
/// <summary>Specify the name of the parameter for this field</summary>
|
|
/// <param name="name">The parameter name (including <tt>:</tt> or <tt>@</tt>)</param>
|
|
/// <returns>A field with the given parameter name specified</returns>
|
|
member this.WithParameterName name =
|
|
{ this with ParameterName = Some name }
|
|
|
|
/// <summary>Specify a qualifier (alias) for the table from which this field will be referenced</summary>
|
|
/// <param name="alias">The table alias for this field comparison</param>
|
|
/// <returns>A field with the given qualifier specified</returns>
|
|
member this.WithQualifier alias =
|
|
{ this with Qualifier = Some alias }
|
|
|
|
/// <summary>Get the qualified path to the field</summary>
|
|
/// <param name="dialect">The SQL dialect to use when converting the name to nested path format</param>
|
|
/// <param name="format">Whether to reference this path as a JSON value or a SQL value</param>
|
|
/// <returns>A <tt>string</tt> with the qualified path required to address the nested document value</returns>
|
|
member this.Path dialect format =
|
|
(this.Qualifier |> Option.map (fun q -> $"{q}.") |> Option.defaultValue "")
|
|
+ Field.NameToPath this.Name dialect format
|
|
|
|
|
|
/// <summary>How fields should be matched</summary>
|
|
[<Struct>]
|
|
type FieldMatch =
|
|
|
|
/// <summary>Any field matches (<tt>OR</tt>)</summary>
|
|
| Any
|
|
|
|
/// <summary>All fields match (<tt>AND</tt>)</summary>
|
|
| All
|
|
|
|
/// <summary>The SQL value implementing each matching strategy</summary>
|
|
override this.ToString() =
|
|
match this with Any -> "OR" | All -> "AND"
|
|
|
|
|
|
/// <summary>Derive parameter names (each instance wraps a counter to uniquely name anonymous fields)</summary>
|
|
type ParameterName() =
|
|
|
|
/// The counter for the next field value
|
|
let mutable currentIdx = -1
|
|
|
|
/// <summary>
|
|
/// Return the specified name for the parameter, or an anonymous parameter name if none is specified
|
|
/// </summary>
|
|
/// <param name="paramName">The optional name of the parameter</param>
|
|
/// <returns>The name of the parameter, derived if no name was provided</returns>
|
|
member this.Derive paramName =
|
|
match paramName with
|
|
| Some it -> it
|
|
| None ->
|
|
currentIdx <- currentIdx + 1
|
|
$"@field{currentIdx}"
|
|
|
|
|
|
/// <summary>Automatically-generated document ID strategies</summary>
|
|
[<Struct>]
|
|
type AutoId =
|
|
|
|
/// <summary>No automatic IDs will be generated</summary>
|
|
| Disabled
|
|
|
|
/// <summary>Generate a MAX-plus-1 numeric value for documents</summary>
|
|
| Number
|
|
|
|
/// <summary>Generate a <tt>GUID</tt> for each document (as a lowercase, no-dashes, 32-character string)</summary>
|
|
| Guid
|
|
|
|
/// <summary>Generate a random string of hexadecimal characters for each document</summary>
|
|
| RandomString
|
|
with
|
|
/// <summary>Generate a <tt>GUID</tt> string</summary>
|
|
/// <returns>A <tt>GUID</tt> string</returns>
|
|
static member GenerateGuid() =
|
|
System.Guid.NewGuid().ToString "N"
|
|
|
|
/// <summary>Generate a string of random hexadecimal characters</summary>
|
|
/// <param name="length">The number of characters to generate</param>
|
|
/// <returns>A string of the given length with random hexadecimal characters</returns>
|
|
static member GenerateRandomString(length: int) =
|
|
RandomNumberGenerator.GetHexString(length, lowercase = true)
|
|
|
|
/// <summary>Does the given document need an automatic ID generated?</summary>
|
|
/// <param name="strategy">The auto-ID strategy currently in use</param>
|
|
/// <param name="document">The document being inserted</param>
|
|
/// <param name="idProp">The name of the ID property in the given document</param>
|
|
/// <returns>True if an auto-ID strategy is implemented and the ID has no value, false otherwise</returns>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// If the ID field type and requested ID value are not compatible
|
|
/// </exception>
|
|
static member NeedsAutoId<'T> strategy (document: 'T) idProp =
|
|
match strategy with
|
|
| Disabled -> false
|
|
| _ ->
|
|
let prop = document.GetType().GetProperty idProp
|
|
if isNull prop then invalidOp $"{idProp} not found in document"
|
|
else
|
|
match strategy with
|
|
| Number ->
|
|
if prop.PropertyType = typeof<int8> then
|
|
let value = prop.GetValue document :?> int8
|
|
value = int8 0
|
|
elif prop.PropertyType = typeof<int16> then
|
|
let value = prop.GetValue document :?> int16
|
|
value = int16 0
|
|
elif prop.PropertyType = typeof<int> then
|
|
let value = prop.GetValue document :?> int
|
|
value = 0
|
|
elif prop.PropertyType = typeof<int64> then
|
|
let value = prop.GetValue document :?> int64
|
|
value = int64 0
|
|
else invalidOp "Document ID was not a number; cannot auto-generate a Number ID"
|
|
| Guid | RandomString ->
|
|
if prop.PropertyType = typeof<string> then
|
|
let value =
|
|
prop.GetValue document
|
|
|> Option.ofObj
|
|
|> Option.map (fun it -> it :?> string)
|
|
|> Option.defaultValue ""
|
|
value = ""
|
|
else invalidOp "Document ID was not a string; cannot auto-generate GUID or random string"
|
|
| Disabled -> false
|
|
|
|
|
|
/// <summary>The required document serialization implementation</summary>
|
|
type IDocumentSerializer =
|
|
|
|
/// <summary>Serialize an object to a JSON string</summary>
|
|
abstract Serialize<'T> : 'T -> string
|
|
|
|
/// <summary>Deserialize a JSON string into an object</summary>
|
|
abstract Deserialize<'T> : string -> 'T
|
|
|
|
|
|
/// <summary>Document serializer defaults</summary>
|
|
module DocumentSerializer =
|
|
|
|
open System.Text.Json
|
|
open System.Text.Json.Serialization
|
|
|
|
/// The default JSON serializer options to use with the stock serializer
|
|
let private jsonDefaultOpts =
|
|
let o = JsonSerializerOptions()
|
|
o.Converters.Add(JsonFSharpConverter())
|
|
o
|
|
|
|
/// <summary>The default JSON serializer</summary>
|
|
[<CompiledName "Default">]
|
|
let ``default`` =
|
|
{ new IDocumentSerializer with
|
|
member _.Serialize<'T>(it: 'T) : string =
|
|
JsonSerializer.Serialize(it, jsonDefaultOpts)
|
|
member _.Deserialize<'T>(it: string) : 'T =
|
|
JsonSerializer.Deserialize<'T>(it, jsonDefaultOpts)
|
|
}
|
|
|
|
|
|
/// <summary>Configuration for document handling</summary>
|
|
[<RequireQualifiedAccess>]
|
|
module Configuration =
|
|
|
|
/// The serializer to use for document manipulation
|
|
let mutable private serializerValue = DocumentSerializer.``default``
|
|
|
|
/// <summary>Register a serializer to use for translating documents to domain types</summary>
|
|
/// <param name="ser">The serializer to use when manipulating documents</param>
|
|
[<CompiledName "UseSerializer">]
|
|
let useSerializer ser =
|
|
serializerValue <- ser
|
|
|
|
/// <summary>Retrieve the currently configured serializer</summary>
|
|
/// <returns>The currently configured serializer</returns>
|
|
[<CompiledName "Serializer">]
|
|
let serializer () =
|
|
serializerValue
|
|
|
|
/// The serialized name of the ID field for documents
|
|
let mutable private idFieldValue = "Id"
|
|
|
|
/// <summary>Specify the name of the ID field for documents</summary>
|
|
/// <param name="it">The name of the ID field for documents</param>
|
|
[<CompiledName "UseIdField">]
|
|
let useIdField it =
|
|
idFieldValue <- it
|
|
|
|
/// <summary>Retrieve the currently configured ID field for documents</summary>
|
|
/// <returns>The currently configured ID field</returns>
|
|
[<CompiledName "IdField">]
|
|
let idField () =
|
|
idFieldValue
|
|
|
|
/// The automatic ID strategy used by the library
|
|
let mutable private autoIdValue = Disabled
|
|
|
|
/// <summary>Specify the automatic ID generation strategy used by the library</summary>
|
|
/// <param name="it">The automatic ID generation strategy to use</param>
|
|
[<CompiledName "UseAutoIdStrategy">]
|
|
let useAutoIdStrategy it =
|
|
autoIdValue <- it
|
|
|
|
/// <summary>Retrieve the currently configured automatic ID generation strategy</summary>
|
|
/// <returns>The current automatic ID generation strategy</returns>
|
|
[<CompiledName "AutoIdStrategy">]
|
|
let autoIdStrategy () =
|
|
autoIdValue
|
|
|
|
/// The length of automatically generated random strings
|
|
let mutable private idStringLengthValue = 16
|
|
|
|
/// <summary>Specify the length of automatically generated random strings</summary>
|
|
/// <param name="length">The length of automatically generated random strings</param>
|
|
[<CompiledName "UseIdStringLength">]
|
|
let useIdStringLength length =
|
|
idStringLengthValue <- length
|
|
|
|
/// <summary>Retrieve the currently configured length of automatically generated random strings</summary>
|
|
/// <returns>The current length of automatically generated random strings</returns>
|
|
[<CompiledName "IdStringLength">]
|
|
let idStringLength () =
|
|
idStringLengthValue
|
|
|
|
|
|
/// <summary>Query construction functions</summary>
|
|
[<RequireQualifiedAccess>]
|
|
module Query =
|
|
|
|
/// <summary>Combine a query (<tt>SELECT</tt>, <tt>UPDATE</tt>, etc.) and a <tt>WHERE</tt> clause</summary>
|
|
/// <param name="statement">The first part of the statement</param>
|
|
/// <param name="where">The <tt>WHERE</tt> clause for the statement</param>
|
|
/// <returns>The two parts of the query combined with <tt>WHERE</tt></returns>
|
|
[<CompiledName "StatementWhere">]
|
|
let statementWhere statement where =
|
|
$"%s{statement} WHERE %s{where}"
|
|
|
|
/// <summary>Queries to define tables and indexes</summary>
|
|
module Definition =
|
|
|
|
/// <summary>SQL statement to create a document table</summary>
|
|
/// <param name="name">The name of the table to create (may include schema)</param>
|
|
/// <param name="dataType">The type of data for the column (<tt>JSON</tt>, <tt>JSONB</tt>, etc.)</param>
|
|
/// <returns>A query to create a document table</returns>
|
|
[<CompiledName "EnsureTableFor">]
|
|
let ensureTableFor name dataType =
|
|
$"CREATE TABLE IF NOT EXISTS %s{name} (data %s{dataType} NOT NULL)"
|
|
|
|
/// Split a schema and table name
|
|
let private splitSchemaAndTable (tableName: string) =
|
|
let parts = tableName.Split '.'
|
|
if Array.length parts = 1 then "", tableName else parts[0], parts[1]
|
|
|
|
/// <summary>SQL statement to create an index on one or more fields in a JSON document</summary>
|
|
/// <param name="tableName">The table on which an index should be created (may include schema)</param>
|
|
/// <param name="indexName">The name of the index to be created</param>
|
|
/// <param name="fields">One or more fields to include in the index</param>
|
|
/// <param name="dialect">The SQL dialect to use when creating this index</param>
|
|
/// <returns>A query to create the field index</returns>
|
|
[<CompiledName "EnsureIndexOn">]
|
|
let ensureIndexOn tableName indexName (fields: string seq) dialect =
|
|
let _, tbl = splitSchemaAndTable tableName
|
|
let jsonFields =
|
|
fields
|
|
|> Seq.map (fun it ->
|
|
let parts = it.Split ' '
|
|
let fieldName = if Array.length parts = 1 then it else parts[0]
|
|
let direction = if Array.length parts < 2 then "" else $" {parts[1]}"
|
|
$"({Field.NameToPath fieldName dialect AsSql}){direction}")
|
|
|> String.concat ", "
|
|
$"CREATE INDEX IF NOT EXISTS idx_{tbl}_%s{indexName} ON {tableName} ({jsonFields})"
|
|
|
|
/// <summary>SQL statement to create a key index for a document table</summary>
|
|
/// <param name="tableName">The table on which a key index should be created (may include schema)</param>
|
|
/// <param name="dialect">The SQL dialect to use when creating this index</param>
|
|
/// <returns>A query to create the key index</returns>
|
|
[<CompiledName "EnsureKey">]
|
|
let ensureKey tableName dialect =
|
|
(ensureIndexOn tableName "key" [ Configuration.idField () ] dialect).Replace("INDEX", "UNIQUE INDEX")
|
|
|
|
/// <summary>Query to insert a document</summary>
|
|
/// <param name="tableName">The table into which to insert (may include schema)</param>
|
|
/// <returns>A query to insert a document</returns>
|
|
[<CompiledName "Insert">]
|
|
let insert tableName =
|
|
$"INSERT INTO %s{tableName} VALUES (@data)"
|
|
|
|
/// <summary>
|
|
/// Query to save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
|
|
/// </summary>
|
|
/// <param name="tableName">The table into which to save (may include schema)</param>
|
|
/// <returns>A query to save a document</returns>
|
|
[<CompiledName "Save">]
|
|
let save tableName =
|
|
sprintf
|
|
"INSERT INTO %s VALUES (@data) ON CONFLICT ((data->>'%s')) DO UPDATE SET data = EXCLUDED.data"
|
|
tableName (Configuration.idField ())
|
|
|
|
/// <summary>Query to count documents in a table</summary>
|
|
/// <param name="tableName">The table in which to count documents (may include schema)</param>
|
|
/// <returns>A query to count documents</returns>
|
|
/// <remarks>This query has no <tt>WHERE</tt> clause</remarks>
|
|
[<CompiledName "Count">]
|
|
let count tableName =
|
|
$"SELECT COUNT(*) AS it FROM %s{tableName}"
|
|
|
|
/// <summary>Query to check for document existence in a table</summary>
|
|
/// <param name="tableName">The table in which existence should be checked (may include schema)</param>
|
|
/// <param name="where">The <tt>WHERE</tt> clause with the existence criteria</param>
|
|
/// <returns>A query to check document existence</returns>
|
|
[<CompiledName "Exists">]
|
|
let exists tableName where =
|
|
$"SELECT EXISTS (SELECT 1 FROM %s{tableName} WHERE %s{where}) AS it"
|
|
|
|
/// <summary>Query to select documents from a table</summary>
|
|
/// <param name="tableName">The table from which documents should be found (may include schema)</param>
|
|
/// <returns>A query to retrieve documents</returns>
|
|
/// <remarks>This query has no <tt>WHERE</tt> clause</remarks>
|
|
[<CompiledName "Find">]
|
|
let find tableName =
|
|
$"SELECT data FROM %s{tableName}"
|
|
|
|
/// <summary>Query to update (replace) a document</summary>
|
|
/// <param name="tableName">The table in which documents should be replaced (may include schema)</param>
|
|
/// <returns>A query to update documents</returns>
|
|
/// <remarks>This query has no <tt>WHERE</tt> clause</remarks>
|
|
[<CompiledName "Update">]
|
|
let update tableName =
|
|
$"UPDATE %s{tableName} SET data = @data"
|
|
|
|
/// <summary>Query to delete documents from a table</summary>
|
|
/// <param name="tableName">The table in which documents should be deleted (may include schema)</param>
|
|
/// <returns>A query to delete documents</returns>
|
|
/// <remarks>This query has no <tt>WHERE</tt> clause</remarks>
|
|
[<CompiledName "Delete">]
|
|
let delete tableName =
|
|
$"DELETE FROM %s{tableName}"
|
|
|
|
/// <summary>Create a SELECT clause to retrieve the document data from the given table</summary>
|
|
/// <param name="tableName">The table from which documents should be found (may include schema)</param>
|
|
/// <returns>A query to retrieve documents</returns>
|
|
[<CompiledName "SelectFromTable">]
|
|
[<System.Obsolete "Use Find instead">]
|
|
let selectFromTable tableName =
|
|
find tableName
|
|
|
|
/// <summary>Create an <tt>ORDER BY</tt> clause for the given fields</summary>
|
|
/// <param name="fields">One or more fields by which to order</param>
|
|
/// <param name="dialect">The SQL dialect for the generated clause</param>
|
|
/// <returns>An <tt>ORDER BY</tt> clause for the given fields</returns>
|
|
[<CompiledName "OrderBy">]
|
|
let orderBy fields dialect =
|
|
if Seq.isEmpty fields then ""
|
|
else
|
|
fields
|
|
|> Seq.map (fun it ->
|
|
if it.Name.Contains ' ' then
|
|
let parts = it.Name.Split ' '
|
|
{ it with Name = parts[0] }, Some $""" {parts |> Array.skip 1 |> String.concat " "}"""
|
|
else it, None)
|
|
|> Seq.map (fun (field, direction) ->
|
|
if field.Name.StartsWith "n:" then
|
|
let f = { field with Name = field.Name[2..] }
|
|
match dialect with
|
|
| PostgreSQL -> $"({f.Path PostgreSQL AsSql})::numeric"
|
|
| SQLite -> f.Path SQLite AsSql
|
|
elif field.Name.StartsWith "i:" then
|
|
let p = { field with Name = field.Name[2..] }.Path dialect AsSql
|
|
match dialect with PostgreSQL -> $"LOWER({p})" | SQLite -> $"{p} COLLATE NOCASE"
|
|
else field.Path dialect AsSql
|
|
|> function path -> path + defaultArg direction "")
|
|
|> String.concat ", "
|
|
|> function it -> $" ORDER BY {it}"
|