namespace BitBadger.Documents.Postgres open Npgsql open Npgsql.FSharp open WithProps ///

F# Extensions for the NpgsqlConnection type

[] module Extensions = type NpgsqlConnection with ///

Execute a query that returns a list of results

/// The query to retrieve the results /// Parameters to use for the query /// The mapping function between the document and the domain item /// A list of results for the given query member conn.customList<'TDoc> query parameters (mapFunc: RowReader -> 'TDoc) = Custom.list<'TDoc> query parameters mapFunc (Sql.existingConnection conn) ///

Execute a query that returns a JSON array of results

/// The query to retrieve the results /// Parameters to use for the query /// The mapping function to extract the document /// A JSON array of results for the given query member conn.customJsonArray query parameters mapFunc = Custom.jsonArray query parameters mapFunc (Sql.existingConnection conn) ///

Execute a query, writing its results to the given PipeWriter

/// The query to retrieve the results /// Parameters to use for the query /// The PipeWriter to which the results should be written /// The mapping function to extract the document member conn.writeCustomJsonArray query parameters writer mapFunc = Custom.writeJsonArray query parameters writer mapFunc (Sql.existingConnection conn) ///

Execute a query that returns one or no results

/// The query to retrieve the results /// Parameters to use for the query /// The mapping function between the document and the domain item /// Some with the first matching result, or None if not found member conn.customSingle<'TDoc> query parameters (mapFunc: RowReader -> 'TDoc) = Custom.single<'TDoc> query parameters mapFunc (Sql.existingConnection conn) ///

Execute a query that returns one or no JSON documents

/// The query to retrieve the results /// Parameters to use for the query /// The mapping function to extract the document /// The JSON document with the first matching result, or an empty document if not found member conn.customJsonSingle query parameters mapFunc = Custom.jsonSingle query parameters mapFunc (Sql.existingConnection conn) ///

Execute a query that returns no results

/// The query to retrieve the results /// Parameters to use for the query member conn.customNonQuery query parameters = Custom.nonQuery query parameters (Sql.existingConnection conn) ///

Execute a query that returns a scalar value

/// The query to retrieve the value /// Parameters to use for the query /// The mapping function to obtain the value /// The scalar value for the query member conn.customScalar<'T when 'T: struct> query parameters (mapFunc: RowReader -> 'T) = Custom.scalar query parameters mapFunc (Sql.existingConnection conn) ///

Create a document table

/// The table whose existence should be ensured (may include schema) member conn.ensureTable name = Definition.ensureTable name (Sql.existingConnection conn) ///

Create an index on documents in the specified table

/// The table to be indexed (may include schema) /// The type of document index to create member conn.ensureDocumentIndex name idxType = Definition.ensureDocumentIndex name idxType (Sql.existingConnection conn) ///

Create an index on field(s) within documents in the specified table

/// The table to be indexed (may include schema) /// The name of the index to create /// One or more fields to be indexed member conn.ensureFieldIndex tableName indexName fields = Definition.ensureFieldIndex tableName indexName fields (Sql.existingConnection conn) ///

Insert a new document

/// The table into which the document should be inserted (may include schema) /// The document to be inserted member conn.insert<'TDoc> tableName (document: 'TDoc) = insert<'TDoc> tableName document (Sql.existingConnection conn) ///

/// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert") ///

/// The table into which the document should be saved (may include schema) /// The document to be saved member conn.save<'TDoc> tableName (document: 'TDoc) = save<'TDoc> tableName document (Sql.existingConnection conn) ///

Count all documents in a table

/// The table in which documents should be counted (may include schema) /// The count of the documents in the table member conn.countAll tableName = Count.all tableName (Sql.existingConnection conn) ///

Count matching documents using JSON field comparisons (->> =, etc.)

/// The table in which documents should be counted (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The count of matching documents in the table member conn.countByFields tableName howMatched fields = Count.byFields tableName howMatched fields (Sql.existingConnection conn) ///

Count matching documents using a JSON containment query (@>)

/// The table in which documents should be counted (may include schema) /// The document to match with the containment query /// The count of the documents in the table member conn.countByContains tableName criteria = Count.byContains tableName criteria (Sql.existingConnection conn) ///

Count matching documents using a JSON Path match query (@?)

/// The table in which documents should be counted (may include schema) /// The JSON Path expression to be matched /// The count of the documents in the table member conn.countByJsonPath tableName jsonPath = Count.byJsonPath tableName jsonPath (Sql.existingConnection conn) ///

Determine if a document exists for the given ID

/// The table in which existence should be checked (may include schema) /// The ID of the document whose existence should be checked /// True if a document exists, false if not member conn.existsById tableName docId = Exists.byId tableName docId (Sql.existingConnection conn) ///

Determine if a document exists using JSON field comparisons (->> =, etc.)

/// The table in which existence should be checked (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// True if any matching documents exist, false if not member conn.existsByFields tableName howMatched fields = Exists.byFields tableName howMatched fields (Sql.existingConnection conn) ///

Determine if a document exists using a JSON containment query (@>)

/// The table in which existence should be checked (may include schema) /// The document to match with the containment query /// True if any matching documents exist, false if not member conn.existsByContains tableName criteria = Exists.byContains tableName criteria (Sql.existingConnection conn) ///

Determine if a document exists using a JSON Path match query (@?)

/// The table in which existence should be checked (may include schema) /// The JSON Path expression to be matched /// True if any matching documents exist, false if not member conn.existsByJsonPath tableName jsonPath = Exists.byJsonPath tableName jsonPath (Sql.existingConnection conn) ///

Retrieve all documents in the given table

/// The table from which documents should be retrieved (may include schema) /// All documents from the given table member conn.findAll<'TDoc> tableName = Find.all<'TDoc> tableName (Sql.existingConnection conn) ///

Retrieve all documents in the given table ordered by the given fields in the document

/// The table from which documents should be retrieved (may include schema) /// Fields by which the results should be ordered /// All documents from the given table, ordered by the given fields member conn.findAllOrdered<'TDoc> tableName orderFields = Find.allOrdered<'TDoc> tableName orderFields (Sql.existingConnection conn) ///

Retrieve a document by its ID

/// The table from which a document should be retrieved (may include schema) /// The ID of the document to retrieve /// Some with the document if found, None otherwise member conn.findById<'TKey, 'TDoc> tableName docId = Find.byId<'TKey, 'TDoc> tableName docId (Sql.existingConnection conn) ///

Retrieve documents matching JSON field comparisons (->> =, etc.)

/// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// All documents matching the given fields member conn.findByFields<'TDoc> tableName howMatched fields = Find.byFields<'TDoc> tableName howMatched fields (Sql.existingConnection conn) ///

/// Retrieve documents matching JSON field comparisons (->> =, etc.) ordered by the given fields in /// the document ///

/// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// All documents matching the given fields, ordered by the other given fields member conn.findByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields = Find.byFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields (Sql.existingConnection conn) ///

Retrieve documents matching a JSON containment query (@>)

/// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// All documents matching the given containment query member conn.findByContains<'TDoc> tableName (criteria: obj) = Find.byContains<'TDoc> tableName criteria (Sql.existingConnection conn) ///

/// Retrieve documents matching a JSON containment query (@>) ordered by the given fields in the /// document ///

/// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// All documents matching the given containment query, ordered by the given fields member conn.findByContainsOrdered<'TDoc> tableName (criteria: obj) orderFields = Find.byContainsOrdered<'TDoc> tableName criteria orderFields (Sql.existingConnection conn) ///

Retrieve documents matching a JSON Path match query (@?)

/// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// All documents matching the given JSON Path expression member conn.findByJsonPath<'TDoc> tableName jsonPath = Find.byJsonPath<'TDoc> tableName jsonPath (Sql.existingConnection conn) ///

/// Retrieve documents matching a JSON Path match query (@?) ordered by the given fields in the document ///

/// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// All documents matching the given JSON Path expression, ordered by the given fields member conn.findByJsonPathOrdered<'TDoc> tableName jsonPath orderFields = Find.byJsonPathOrdered<'TDoc> tableName jsonPath orderFields (Sql.existingConnection conn) ///

Retrieve the first document matching JSON field comparisons (->> =, etc.)

/// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Some with the first document, or None if not found member conn.findFirstByFields<'TDoc> tableName howMatched fields = Find.firstByFields<'TDoc> tableName howMatched fields (Sql.existingConnection conn) ///

/// Retrieve the first document matching JSON field comparisons (->> =, etc.) ordered by the given /// fields in the document ///

/// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// /// Some with the first document ordered by the given fields, or None if not found /// member conn.findFirstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields = Find.firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields (Sql.existingConnection conn) ///

Retrieve the first document matching a JSON containment query (@>)

/// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// Some with the first document, or None if not found member conn.findFirstByContains<'TDoc> tableName (criteria: obj) = Find.firstByContains<'TDoc> tableName criteria (Sql.existingConnection conn) ///

/// Retrieve the first document matching a JSON containment query (@>) ordered by the given fields in /// the document ///

/// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// /// Some with the first document ordered by the given fields, or None if not found /// member conn.findFirstByContainsOrdered<'TDoc> tableName (criteria: obj) orderFields = Find.firstByContainsOrdered<'TDoc> tableName criteria orderFields (Sql.existingConnection conn) ///

Retrieve the first document matching a JSON Path match query (@?)

/// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// Some with the first document, or None if not found member conn.findFirstByJsonPath<'TDoc> tableName jsonPath = Find.firstByJsonPath<'TDoc> tableName jsonPath (Sql.existingConnection conn) ///

/// Retrieve the first document matching a JSON Path match query (@?) ordered by the given fields in the /// document ///

/// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// /// Some with the first document ordered by the given fields, or None if not found /// member conn.findFirstByJsonPathOrdered<'TDoc> tableName jsonPath orderFields = Find.firstByJsonPathOrdered<'TDoc> tableName jsonPath orderFields (Sql.existingConnection conn) ///

Retrieve all documents in the given table as a JSON array

/// The table from which documents should be retrieved (may include schema) /// All documents from the given table as a JSON array member conn.jsonAll tableName = Json.all tableName (Sql.existingConnection conn) ///

Write all documents in the given table to the given PipeWriter

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written member conn.writeJsonAll tableName writer = Json.writeAll tableName writer (Sql.existingConnection conn) ///

/// Retrieve all documents in the given table as a JSON array, ordered by the given fields in the document ///

/// The table from which documents should be retrieved (may include schema) /// Fields by which the results should be ordered /// All documents from the given table as a JSON array, ordered by the given fields member conn.jsonAllOrdered tableName orderFields = Json.allOrdered tableName orderFields (Sql.existingConnection conn) ///

/// Write all documents in the given table to the given PipeWriter, ordered by the given fields in the /// document ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Fields by which the results should be ordered member conn.writeJsonAllOrdered tableName writer orderFields = Json.writeAllOrdered tableName writer orderFields (Sql.existingConnection conn) ///

Retrieve a JSON document by its ID

/// The table from which a document should be retrieved (may include schema) /// The ID of the document to retrieve /// The JSON document if found, an empty JSON document otherwise member conn.jsonById<'TKey> tableName (docId: 'TKey) = Json.byId tableName docId (Sql.existingConnection conn) ///

Write a JSON document to the given PipeWriter by its ID

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The ID of the document to retrieve member conn.writeJsonById<'TKey> tableName writer (docId: 'TKey) = Json.writeById tableName writer docId (Sql.existingConnection conn) ///

Retrieve JSON documents matching JSON field comparisons (->> =, etc.)

/// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// All JSON documents matching the given fields member conn.jsonByFields tableName howMatched fields = Json.byFields tableName howMatched fields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching JSON field comparisons (->> =, /// etc.) ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match member conn.writeJsonByFields tableName writer howMatched fields = Json.writeByFields tableName writer howMatched fields (Sql.existingConnection conn) ///

/// Retrieve JSON documents matching JSON field comparisons (->> =, etc.) ordered by the given /// fields in the document ///

/// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// All JSON documents matching the given fields, ordered by the other given fields member conn.jsonByFieldsOrdered tableName howMatched queryFields orderFields = Json.byFieldsOrdered tableName howMatched queryFields orderFields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching JSON field comparisons (->> =, /// etc.) ordered by the given fields in the document ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered member conn.writeJsonByFieldsOrdered tableName writer howMatched queryFields orderFields = Json.writeByFieldsOrdered tableName writer howMatched queryFields orderFields (Sql.existingConnection conn) ///

Retrieve JSON documents matching a JSON containment query (@>)

/// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// All JSON documents matching the given containment query member conn.jsonByContains tableName (criteria: obj) = Json.byContains tableName criteria (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON containment query (@>) ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query member conn.writeJsonByContains tableName writer (criteria: obj) = Json.writeByContains tableName writer criteria (Sql.existingConnection conn) ///

/// Retrieve JSON documents matching a JSON containment query (@>) ordered by the given fields in the /// document ///

/// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// All documents matching the given containment query, ordered by the given fields member conn.jsonByContainsOrdered tableName (criteria: obj) orderFields = Json.byContainsOrdered tableName criteria orderFields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON containment query (@>) ordered /// by the given fields in the document ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query /// Fields by which the results should be ordered member conn.writeJsonByContainsOrdered tableName writer (criteria: obj) orderFields = Json.writeByContainsOrdered tableName writer criteria orderFields (Sql.existingConnection conn) ///

Retrieve JSON documents matching a JSON Path match query (@?)

/// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// All JSON documents matching the given JSON Path expression member conn.jsonByJsonPath tableName jsonPath = Json.byJsonPath tableName jsonPath (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON Path match query (@?) ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match member conn.writeJsonByJsonPath tableName writer jsonPath = Json.writeByJsonPath tableName writer jsonPath (Sql.existingConnection conn) ///

/// Retrieve JSON documents matching a JSON Path match query (@?) ordered by the given fields in the /// document ///

/// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// All JSON documents matching the given JSON Path expression, ordered by the given fields member conn.jsonByJsonPathOrdered tableName jsonPath orderFields = Json.byJsonPathOrdered tableName jsonPath orderFields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON Path match query (@?) ordered by /// the given fields in the document ///

/// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match /// Fields by which the results should be ordered member conn.writeJsonByJsonPathOrdered tableName writer jsonPath orderFields = Json.writeByJsonPathOrdered tableName writer jsonPath orderFields (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching JSON field comparisons (->> =, etc.) ///

/// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The first matching JSON document if found, an empty JSON document otherwise member conn.jsonFirstByFields tableName howMatched fields = Json.firstByFields tableName howMatched fields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching JSON field comparisons /// (->> =, etc.) ///

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match member conn.writeJsonFirstByFields tableName writer howMatched fields = Json.writeFirstByFields tableName writer howMatched fields (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching JSON field comparisons (->> =, etc.) ordered by the /// given fields in the document ///

/// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// The first matching JSON document if found, an empty JSON document otherwise member conn.jsonFirstByFieldsOrdered tableName howMatched queryFields orderFields = Json.firstByFieldsOrdered tableName howMatched queryFields orderFields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching JSON field comparisons /// (->> =, etc.) ordered by the given fields in the document ///

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered member conn.writeJsonFirstByFieldsOrdered tableName writer howMatched queryFields orderFields = Json.writeFirstByFieldsOrdered tableName writer howMatched queryFields orderFields (Sql.existingConnection conn) ///

Retrieve the first JSON document matching a JSON containment query (@>)

/// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// The first matching JSON document if found, an empty JSON document otherwise member conn.jsonFirstByContains tableName (criteria: obj) = Json.firstByContains tableName criteria (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON containment query /// (@>) ///

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query member conn.writeJsonFirstByContains tableName writer (criteria: obj) = Json.writeFirstByContains tableName writer criteria (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching a JSON containment query (@>) ordered by the given /// fields in the document ///

/// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// The first matching JSON document if found, an empty JSON document otherwise member conn.jsonFirstByContainsOrdered tableName (criteria: obj) orderFields = Json.firstByContainsOrdered tableName criteria orderFields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON containment query /// (@>) ordered by the given fields in the document ///

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query /// Fields by which the results should be ordered member conn.writeJsonFirstByContainsOrdered tableName writer (criteria: obj) orderFields = Json.writeFirstByContainsOrdered tableName writer criteria orderFields (Sql.existingConnection conn) ///

Retrieve the first JSON document matching a JSON Path match query (@?)

/// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// The first matching JSON document if found, an empty JSON document otherwise member conn.jsonFirstByJsonPath tableName jsonPath = Json.firstByJsonPath tableName jsonPath (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON Path match query (@?) ///

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match member conn.writeJsonFirstByJsonPath tableName writer jsonPath = Json.writeFirstByJsonPath tableName writer jsonPath (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching a JSON Path match query (@?) ordered by the given fields /// in the document ///

/// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// The first matching JSON document if found, an empty JSON document otherwise member conn.jsonFirstByJsonPathOrdered tableName jsonPath orderFields = Json.firstByJsonPathOrdered tableName jsonPath orderFields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON Path match query (@?) /// ordered by the given fields in the document ///

/// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match /// Fields by which the results should be ordered member conn.writeJsonFirstByJsonPathOrdered tableName writer jsonPath orderFields = Json.writeFirstByJsonPathOrdered tableName writer jsonPath orderFields (Sql.existingConnection conn) ///

Update (replace) an entire document by its ID

/// The table in which a document should be updated (may include schema) /// The ID of the document to be updated (replaced) /// The new document member conn.updateById tableName (docId: 'TKey) (document: 'TDoc) = Update.byId tableName docId document (Sql.existingConnection conn) ///

/// Update (replace) an entire document by its ID, using the provided function to obtain the ID from the /// document ///

/// The table in which a document should be updated (may include schema) /// The function to obtain the ID of the document /// The new document member conn.updateByFunc tableName (idFunc: 'TDoc -> 'TKey) (document: 'TDoc) = Update.byFunc tableName idFunc document (Sql.existingConnection conn) ///

Patch a document by its ID

/// The table in which a document should be patched (may include schema) /// The ID of the document to patch /// The partial document to patch the existing document member conn.patchById tableName (docId: 'TKey) (patch: 'TPatch) = Patch.byId tableName docId patch (Sql.existingConnection conn) ///

/// Patch documents using a JSON field comparison query in the WHERE clause (->> =, /// etc.) ///

/// The table in which documents should be patched (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The partial document to patch the existing document member conn.patchByFields tableName howMatched fields (patch: 'TPatch) = Patch.byFields tableName howMatched fields patch (Sql.existingConnection conn) ///

/// Patch documents using a JSON containment query in the WHERE clause (@>) ///

/// The table in which documents should be patched (may include schema) /// The document to match the containment query /// The partial document to patch the existing document member conn.patchByContains tableName (criteria: 'TCriteria) (patch: 'TPatch) = Patch.byContains tableName criteria patch (Sql.existingConnection conn) ///

Patch documents using a JSON Path match query in the WHERE clause (@?)

/// The table in which documents should be patched (may include schema) /// The JSON Path expression to match /// The partial document to patch the existing document member conn.patchByJsonPath tableName jsonPath (patch: 'TPatch) = Patch.byJsonPath tableName jsonPath patch (Sql.existingConnection conn) ///

Remove fields from a document by the document's ID

/// The table in which a document should be modified (may include schema) /// The ID of the document to modify /// One or more field names to remove from the document member conn.removeFieldsById tableName (docId: 'TKey) fieldNames = RemoveFields.byId tableName docId fieldNames (Sql.existingConnection conn) ///

Remove fields from documents via a comparison on JSON fields in the document

/// The table in which documents should be modified (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// One or more field names to remove from the matching documents member conn.removeFieldsByFields tableName howMatched fields fieldNames = RemoveFields.byFields tableName howMatched fields fieldNames (Sql.existingConnection conn) ///

Remove fields from documents via a JSON containment query (@>)

/// The table in which documents should be modified (may include schema) /// The document to match the containment query /// One or more field names to remove from the matching documents member conn.removeFieldsByContains tableName (criteria: 'TContains) fieldNames = RemoveFields.byContains tableName criteria fieldNames (Sql.existingConnection conn) ///

Remove fields from documents via a JSON Path match query (@?)

/// The table in which documents should be modified (may include schema) /// The JSON Path expression to match /// One or more field names to remove from the matching documents member conn.removeFieldsByJsonPath tableName jsonPath fieldNames = RemoveFields.byJsonPath tableName jsonPath fieldNames (Sql.existingConnection conn) ///

Delete a document by its ID

/// The table in which a document should be deleted (may include schema) /// The ID of the document to delete member conn.deleteById tableName (docId: 'TKey) = Delete.byId tableName docId (Sql.existingConnection conn) ///

Delete documents by matching a JSON field comparison query (->> =, etc.)

/// The table in which documents should be deleted (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match member conn.deleteByFields tableName howMatched fields = Delete.byFields tableName howMatched fields (Sql.existingConnection conn) ///

Delete documents by matching a JSON contains query (@>)

/// The table in which documents should be deleted (may include schema) /// The document to match the containment query member conn.deleteByContains tableName (criteria: 'TContains) = Delete.byContains tableName criteria (Sql.existingConnection conn) ///

Delete documents by matching a JSON Path match query (@?)

/// The table in which documents should be deleted (may include schema) /// The JSON Path expression to match member conn.deleteByJsonPath tableName jsonPath = Delete.byJsonPath tableName jsonPath (Sql.existingConnection conn) open System.Runtime.CompilerServices ///

C# extensions on the NpgsqlConnection type

type NpgsqlConnectionCSharpExtensions = ///

Execute a query that returns a list of results

/// The NpgsqlConnection on which to run the query /// The query to retrieve the results /// Parameters to use for the query /// The mapping function between the document and the domain item /// A list of results for the given query [] static member inline CustomList<'TDoc>(conn, query, parameters, mapFunc: System.Func) = Custom.List<'TDoc>(query, parameters, mapFunc, Sql.existingConnection conn) ///

Execute a query that returns a JSON array of results

/// The NpgsqlConnection on which to run the query /// The query to retrieve the results /// Parameters to use for the query /// The mapping function to extract the document /// A JSON array of results for the given query [] static member inline CustomJsonArray(conn, query, parameters, mapFunc) = Custom.JsonArray(query, parameters, mapFunc, Sql.existingConnection conn) ///

Execute a query, writing its results to the given PipeWriter

/// The NpgsqlConnection on which to run the query /// The query to retrieve the results /// Parameters to use for the query /// The PipeWriter to which the results should be written /// The mapping function to extract the document [] static member inline WriteCustomJsonArray(conn, query, parameters, writer, mapFunc) = Custom.WriteJsonArray(query, parameters, writer, mapFunc, Sql.existingConnection conn) ///

Execute a query that returns one or no results

/// The NpgsqlConnection on which to run the query /// The query to retrieve the results /// Parameters to use for the query /// The mapping function between the document and the domain item /// The first matching result, or null if not found [] static member inline CustomSingle<'TDoc when 'TDoc: null and 'TDoc: not struct>( conn, query, parameters, mapFunc: System.Func) = Custom.Single<'TDoc>(query, parameters, mapFunc, Sql.existingConnection conn) ///

Execute a query that returns one or no JSON documents

/// The NpgsqlConnection on which to run the query /// The query to retrieve the results /// Parameters to use for the query /// The mapping function to extract the document /// The JSON document with the first matching result, or an empty document if not found [] static member inline CustomJsonSingle(conn, query, parameters, mapFunc) = Custom.JsonSingle(query, parameters, mapFunc, Sql.existingConnection conn) ///

Execute a query that returns no results

/// The NpgsqlConnection on which to run the query /// The query to retrieve the results /// Parameters to use for the query [] static member inline CustomNonQuery(conn, query, parameters) = Custom.nonQuery query parameters (Sql.existingConnection conn) ///

Execute a query that returns a scalar value

/// The NpgsqlConnection on which to run the query /// The query to retrieve the value /// Parameters to use for the query /// The mapping function to obtain the value /// The scalar value for the query [] static member inline CustomScalar<'T when 'T: struct>( conn, query, parameters, mapFunc: System.Func) = Custom.Scalar(query, parameters, mapFunc, Sql.existingConnection conn) ///

Create a document table

/// The NpgsqlConnection on which to run the query /// The table whose existence should be ensured (may include schema) [] static member inline EnsureTable(conn, name) = Definition.ensureTable name (Sql.existingConnection conn) ///

Create an index on documents in the specified table

/// The NpgsqlConnection on which to run the query /// The table to be indexed (may include schema) /// The type of document index to create [] static member inline EnsureDocumentIndex(conn, name, idxType) = Definition.ensureDocumentIndex name idxType (Sql.existingConnection conn) ///

Create an index on field(s) within documents in the specified table

/// The NpgsqlConnection on which to run the query /// The table to be indexed (may include schema) /// The name of the index to create /// One or more fields to be indexed [] static member inline EnsureFieldIndex(conn, tableName, indexName, fields) = Definition.ensureFieldIndex tableName indexName fields (Sql.existingConnection conn) ///

Insert a new document

/// The NpgsqlConnection on which to run the query /// The table into which the document should be inserted (may include schema) /// The document to be inserted [] static member inline Insert<'TDoc>(conn, tableName, document: 'TDoc) = insert<'TDoc> tableName document (Sql.existingConnection conn) ///

Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")

/// The NpgsqlConnection on which to run the query /// The table into which the document should be saved (may include schema) /// The document to be saved [] static member inline Save<'TDoc>(conn, tableName, document: 'TDoc) = save<'TDoc> tableName document (Sql.existingConnection conn) ///

Count all documents in a table

/// The NpgsqlConnection on which to run the query /// The table in which documents should be counted (may include schema) /// The count of the documents in the table [] static member inline CountAll(conn, tableName) = Count.all tableName (Sql.existingConnection conn) ///

Count matching documents using JSON field comparisons (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be counted (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The count of matching documents in the table [] static member inline CountByFields(conn, tableName, howMatched, fields) = Count.byFields tableName howMatched fields (Sql.existingConnection conn) ///

Count matching documents using a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be counted (may include schema) /// The document to match with the containment query /// The count of the documents in the table [] static member inline CountByContains(conn, tableName, criteria: 'TCriteria) = Count.byContains tableName criteria (Sql.existingConnection conn) ///

Count matching documents using a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be counted (may include schema) /// The JSON Path expression to be matched /// The count of the documents in the table [] static member inline CountByJsonPath(conn, tableName, jsonPath) = Count.byJsonPath tableName jsonPath (Sql.existingConnection conn) ///

Determine if a document exists for the given ID

/// The NpgsqlConnection on which to run the query /// The table in which existence should be checked (may include schema) /// The ID of the document whose existence should be checked /// True if a document exists, false if not [] static member inline ExistsById(conn, tableName, docId) = Exists.byId tableName docId (Sql.existingConnection conn) ///

Determine if a document exists using JSON field comparisons (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table in which existence should be checked (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// True if any matching documents exist, false if not [] static member inline ExistsByFields(conn, tableName, howMatched, fields) = Exists.byFields tableName howMatched fields (Sql.existingConnection conn) ///

Determine if a document exists using a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table in which existence should be checked (may include schema) /// The document to match with the containment query /// True if any matching documents exist, false if not [] static member inline ExistsByContains(conn, tableName, criteria: 'TCriteria) = Exists.byContains tableName criteria (Sql.existingConnection conn) ///

Determine if a document exists using a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table in which existence should be checked (may include schema) /// The JSON Path expression to be matched /// True if any matching documents exist, false if not [] static member inline ExistsByJsonPath(conn, tableName, jsonPath) = Exists.byJsonPath tableName jsonPath (Sql.existingConnection conn) ///

Retrieve all documents in the given table

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// All documents from the given table [] static member inline FindAll<'TDoc>(conn, tableName) = Find.All<'TDoc>(tableName, Sql.existingConnection conn) ///

Retrieve all documents in the given table ordered by the given fields in the document

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// Fields by which the results should be ordered /// All documents from the given table, ordered by the given fields [] static member inline FindAllOrdered<'TDoc>(conn, tableName, orderFields) = Find.AllOrdered<'TDoc>(tableName, orderFields, Sql.existingConnection conn) ///

Retrieve a document by its ID

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The ID of the document to retrieve /// The document if found, null otherwise [] static member inline FindById<'TKey, 'TDoc when 'TDoc: null and 'TDoc: not struct>(conn, tableName, docId: 'TKey) = Find.ById<'TKey, 'TDoc>(tableName, docId, Sql.existingConnection conn) ///

Retrieve documents matching JSON field comparisons (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// All documents matching the given fields [] static member inline FindByFields<'TDoc>(conn, tableName, howMatched, fields) = Find.ByFields<'TDoc>(tableName, howMatched, fields, Sql.existingConnection conn) ///

/// Retrieve documents matching JSON field comparisons (->> =, etc.) ordered by the given fields in the /// document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// All documents matching the given fields, ordered by the other given fields [] static member inline FindByFieldsOrdered<'TDoc>(conn, tableName, howMatched, queryFields, orderFields) = Find.ByFieldsOrdered<'TDoc>( tableName, howMatched, queryFields, orderFields, Sql.existingConnection conn) ///

Retrieve documents matching a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// All documents matching the given containment query [] static member inline FindByContains<'TDoc>(conn, tableName, criteria: obj) = Find.ByContains<'TDoc>(tableName, criteria, Sql.existingConnection conn) ///

/// Retrieve documents matching a JSON containment query (@>) ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// All documents matching the given containment query, ordered by the given fields [] static member inline FindByContainsOrdered<'TDoc>(conn, tableName, criteria: obj, orderFields) = Find.ByContainsOrdered<'TDoc>(tableName, criteria, orderFields, Sql.existingConnection conn) ///

Retrieve documents matching a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// All documents matching the given JSON Path expression [] static member inline FindByJsonPath<'TDoc>(conn, tableName, jsonPath) = Find.ByJsonPath<'TDoc>(tableName, jsonPath, Sql.existingConnection conn) ///

/// Retrieve documents matching a JSON Path match query (@?) ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// All documents matching the given JSON Path expression, ordered by the given fields [] static member inline FindByJsonPathOrdered<'TDoc>(conn, tableName, jsonPath, orderFields) = Find.ByJsonPathOrdered<'TDoc>(tableName, jsonPath, orderFields, Sql.existingConnection conn) ///

Retrieve the first document matching JSON field comparisons (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The first document, or null if not found [] static member inline FindFirstByFields<'TDoc when 'TDoc: null and 'TDoc: not struct>( conn, tableName, howMatched, fields) = Find.FirstByFields<'TDoc>(tableName, howMatched, fields, Sql.existingConnection conn) ///

/// Retrieve the first document matching JSON field comparisons (->> =, etc.) ordered by the given /// fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// The first document ordered by the given fields, or null if not found [] static member inline FindFirstByFieldsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>( conn, tableName, howMatched, queryFields, orderFields) = Find.FirstByFieldsOrdered<'TDoc>( tableName, howMatched, queryFields, orderFields, Sql.existingConnection conn) ///

Retrieve the first document matching a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// The first document, or null if not found [] static member inline FindFirstByContains<'TDoc when 'TDoc: null and 'TDoc: not struct>( conn, tableName, criteria: obj) = Find.FirstByContains<'TDoc>(tableName, criteria, Sql.existingConnection conn) ///

/// Retrieve the first document matching a JSON containment query (@>) ordered by the given fields in the /// document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// The first document ordered by the given fields, or null if not found [] static member inline FindFirstByContainsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>( conn, tableName, criteria: obj, orderFields) = Find.FirstByContainsOrdered<'TDoc>(tableName, criteria, orderFields, Sql.existingConnection conn) ///

Retrieve the first document matching a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// The first document, or null if not found [] static member inline FindFirstByJsonPath<'TDoc when 'TDoc: null and 'TDoc: not struct>(conn, tableName, jsonPath) = Find.FirstByJsonPath<'TDoc>(tableName, jsonPath, Sql.existingConnection conn) ///

/// Retrieve the first document matching a JSON Path match query (@?) ordered by the given fields in the /// document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// The first document ordered by the given fields, or null if not found [] static member inline FindFirstByJsonPathOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>( conn, tableName, jsonPath, orderFields) = Find.FirstByJsonPathOrdered<'TDoc>(tableName, jsonPath, orderFields, Sql.existingConnection conn) ///

Retrieve all documents in the given table as a JSON array

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// All documents from the given table as a JSON array [] static member inline JsonAll(conn, tableName) = Json.all tableName (Sql.existingConnection conn) ///

Write all documents in the given table to the given PipeWriter

/// Retrieve all documents in the given table as a JSON array, ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// Fields by which the results should be ordered /// All documents from the given table as a JSON array, ordered by the given fields [] static member inline JsonAllOrdered(conn, tableName, orderFields) = Json.allOrdered tableName orderFields (Sql.existingConnection conn) ///

/// Write all documents in the given table to the given PipeWriter, ordered by the given fields in the /// document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Fields by which the results should be ordered [] static member inline WriteJsonAllOrdered(conn, tableName, writer, orderFields) = Json.writeAllOrdered tableName writer orderFields (Sql.existingConnection conn) ///

Retrieve a JSON document by its ID

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The ID of the document to retrieve /// The JSON document if found, an empty JSON document otherwise [] static member inline JsonById<'TKey>(conn, tableName, docId: 'TKey) = Json.byId tableName docId (Sql.existingConnection conn) ///

Write a JSON document to the given PipeWriter by its ID

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The ID of the document to retrieve [] static member inline WriteJsonById<'TKey>(conn, tableName, writer, docId) = Json.writeById tableName writer docId (Sql.existingConnection conn) ///

Retrieve JSON documents matching JSON field comparisons (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// All JSON documents matching the given fields [] static member inline JsonByFields(conn, tableName, howMatched, fields) = Json.byFields tableName howMatched fields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching JSON field comparisons (->> =, etc.) ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match [] static member inline WriteJsonByFields(conn, tableName, writer, howMatched, fields) = Json.writeByFields tableName writer howMatched fields (Sql.existingConnection conn) ///

/// Retrieve JSON documents matching JSON field comparisons (->> =, etc.) ordered by the given fields /// in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// All JSON documents matching the given fields, ordered by the other given fields [] static member inline JsonByFieldsOrdered(conn, tableName, howMatched, queryFields, orderFields) = Json.byFieldsOrdered tableName howMatched queryFields orderFields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching JSON field comparisons (->> =, etc.) /// ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered [] static member inline WriteJsonByFieldsOrdered(conn, tableName, writer, howMatched, queryFields, orderFields) = Json.writeByFieldsOrdered tableName writer howMatched queryFields orderFields (Sql.existingConnection conn) ///

Retrieve JSON documents matching a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// All JSON documents matching the given containment query [] static member inline JsonByContains(conn, tableName, criteria: obj) = Json.byContains tableName criteria (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON containment query (@>) ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query [] static member inline WriteJsonByContains(conn, tableName, writer, criteria: obj) = Json.writeByContains tableName writer criteria (Sql.existingConnection conn) ///

/// Retrieve JSON documents matching a JSON containment query (@>) ordered by the given fields in the /// document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// All documents matching the given containment query, ordered by the given fields [] static member inline JsonByContainsOrdered(conn, tableName, criteria: obj, orderFields) = Json.byContainsOrdered tableName criteria orderFields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON containment query (@>) ordered by /// the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query /// Fields by which the results should be ordered [] static member inline WriteJsonByContainsOrdered(conn, tableName, writer, criteria: obj, orderFields) = Json.writeByContainsOrdered tableName writer criteria orderFields (Sql.existingConnection conn) ///

Retrieve JSON documents matching a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// All JSON documents matching the given JSON Path expression [] static member inline JsonByJsonPath(conn, tableName, jsonPath) = Json.byJsonPath tableName jsonPath (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON Path match query (@?) ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match [] static member inline WriteJsonByJsonPath(conn, tableName, writer, jsonPath) = Json.writeByJsonPath tableName writer jsonPath (Sql.existingConnection conn) ///

/// Retrieve JSON documents matching a JSON Path match query (@?) ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// All JSON documents matching the given JSON Path expression, ordered by the given fields [] static member inline JsonByJsonPathOrdered(conn, tableName, jsonPath, orderFields) = Json.byJsonPathOrdered tableName jsonPath orderFields (Sql.existingConnection conn) ///

/// Write JSON documents to the given PipeWriter matching a JSON Path match query (@?) ordered by the /// given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which documents should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match /// Fields by which the results should be ordered [] static member inline WriteJsonByJsonPathOrdered(conn, tableName, writer, jsonPath, orderFields) = Json.writeByJsonPathOrdered tableName writer jsonPath orderFields (Sql.existingConnection conn) ///

Retrieve the first JSON document matching JSON field comparisons (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The first matching JSON document if found, an empty JSON document otherwise [] static member inline JsonFirstByFields(conn, tableName, howMatched, fields) = Json.firstByFields tableName howMatched fields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching JSON field comparisons /// (->> =, etc.) ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match [] static member inline WriteJsonFirstByFields(conn, tableName, writer, howMatched, fields) = Json.writeFirstByFields tableName writer howMatched fields (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching JSON field comparisons (->> =, etc.) ordered by the /// given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered /// The first matching JSON document if found, an empty JSON document otherwise [] static member inline JsonFirstByFieldsOrdered(conn, tableName, howMatched, queryFields, orderFields) = Json.firstByFieldsOrdered tableName howMatched queryFields orderFields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching JSON field comparisons /// (->> =, etc.) ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// Whether to match any or all of the field conditions /// The field conditions to match /// Fields by which the results should be ordered [] static member inline WriteJsonFirstByFieldsOrdered(conn, tableName, writer, howMatched, queryFields, orderFields) = Json.writeFirstByFieldsOrdered tableName writer howMatched queryFields orderFields (Sql.existingConnection conn) ///

Retrieve the first JSON document matching a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// The first matching JSON document if found, an empty JSON document otherwise [] static member inline JsonFirstByContains(conn, tableName, criteria: obj) = Json.firstByContains tableName criteria (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON containment query (@>) ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query [] static member inline WriteJsonFirstByContains(conn, tableName, writer, criteria: obj) = Json.writeFirstByContains tableName writer criteria (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching a JSON containment query (@>) ordered by the given fields in /// the document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The document to match with the containment query /// Fields by which the results should be ordered /// The first matching JSON document if found, an empty JSON document otherwise [] static member inline JsonFirstByContainsOrdered(conn, tableName, criteria: obj, orderFields) = Json.firstByContainsOrdered tableName criteria orderFields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON containment query (@>) /// ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The document to match with the containment query /// Fields by which the results should be ordered [] static member inline WriteJsonFirstByContainsOrdered(conn, tableName, writer, criteria: obj, orderFields) = Json.writeFirstByContainsOrdered tableName writer criteria orderFields (Sql.existingConnection conn) ///

Retrieve the first JSON document matching a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// The first matching JSON document if found, an empty JSON document otherwise [] static member inline JsonFirstByJsonPath(conn, tableName, jsonPath) = Json.firstByJsonPath tableName jsonPath (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON Path match query (@?) ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match [] static member inline WriteJsonFirstByJsonPath(conn, tableName, writer, jsonPath) = Json.writeFirstByJsonPath tableName writer jsonPath (Sql.existingConnection conn) ///

/// Retrieve the first JSON document matching a JSON Path match query (@?) ordered by the given fields in the /// document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The JSON Path expression to match /// Fields by which the results should be ordered /// The first matching JSON document if found, an empty JSON document otherwise [] static member inline JsonFirstByJsonPathOrdered(conn, tableName, jsonPath, orderFields) = Json.firstByJsonPathOrdered tableName jsonPath orderFields (Sql.existingConnection conn) ///

/// Write the first JSON document to the given PipeWriter matching a JSON Path match query (@?) /// ordered by the given fields in the document ///

/// The NpgsqlConnection on which to run the query /// The table from which a document should be retrieved (may include schema) /// The PipeWriter to which the results should be written /// The JSON Path expression to match /// Fields by which the results should be ordered [] static member inline WriteJsonFirstByJsonPathOrdered(conn, tableName, writer, jsonPath, orderFields) = Json.writeFirstByJsonPathOrdered tableName writer jsonPath orderFields (Sql.existingConnection conn) ///

Update (replace) an entire document by its ID

/// The NpgsqlConnection on which to run the query /// The table in which a document should be updated (may include schema) /// The ID of the document to be updated (replaced) /// The new document [] static member inline UpdateById(conn, tableName, docId: 'TKey, document: 'TDoc) = Update.byId tableName docId document (Sql.existingConnection conn) ///

/// Update (replace) an entire document by its ID, using the provided function to obtain the ID from the document ///

/// The NpgsqlConnection on which to run the query /// The table in which a document should be updated (may include schema) /// The function to obtain the ID of the document /// The new document [] static member inline UpdateByFunc(conn, tableName, idFunc: System.Func<'TDoc, 'TKey>, document: 'TDoc) = Update.ByFunc(tableName, idFunc, document, Sql.existingConnection conn) ///

Patch a document by its ID

/// The NpgsqlConnection on which to run the query /// The table in which a document should be patched (may include schema) /// The ID of the document to patch /// The partial document to patch the existing document [] static member inline PatchById(conn, tableName, docId: 'TKey, patch: 'TPatch) = Patch.byId tableName docId patch (Sql.existingConnection conn) ///

/// Patch documents using a JSON field comparison query in the WHERE clause (->> =, etc.) ///

/// The NpgsqlConnection on which to run the query /// The table in which documents should be patched (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// The partial document to patch the existing document [] static member inline PatchByFields(conn, tableName, howMatched, fields, patch: 'TPatch) = Patch.byFields tableName howMatched fields patch (Sql.existingConnection conn) ///

Patch documents using a JSON containment query in the WHERE clause (@>)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be patched (may include schema) /// The document to match the containment query /// The partial document to patch the existing document [] static member inline PatchByContains(conn, tableName, criteria: 'TCriteria, patch: 'TPatch) = Patch.byContains tableName criteria patch (Sql.existingConnection conn) ///

Patch documents using a JSON Path match query in the WHERE clause (@?)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be patched (may include schema) /// The JSON Path expression to match /// The partial document to patch the existing document [] static member inline PatchByJsonPath(conn, tableName, jsonPath, patch: 'TPatch) = Patch.byJsonPath tableName jsonPath patch (Sql.existingConnection conn) ///

Remove fields from a document by the document's ID

/// The NpgsqlConnection on which to run the query /// The table in which a document should be modified (may include schema) /// The ID of the document to modify /// One or more field names to remove from the document [] static member inline RemoveFieldsById(conn, tableName, docId: 'TKey, fieldNames) = RemoveFields.byId tableName docId fieldNames (Sql.existingConnection conn) ///

Remove fields from documents via a comparison on JSON fields in the document

/// The NpgsqlConnection on which to run the query /// The table in which documents should be modified (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match /// One or more field names to remove from the matching documents [] static member inline RemoveFieldsByFields(conn, tableName, howMatched, fields, fieldNames) = RemoveFields.byFields tableName howMatched fields fieldNames (Sql.existingConnection conn) ///

Remove fields from documents via a JSON containment query (@>)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be modified (may include schema) /// The document to match the containment query /// One or more field names to remove from the matching documents [] static member inline RemoveFieldsByContains(conn, tableName, criteria: 'TContains, fieldNames) = RemoveFields.byContains tableName criteria fieldNames (Sql.existingConnection conn) ///

Remove fields from documents via a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be modified (may include schema) /// The JSON Path expression to match /// One or more field names to remove from the matching documents [] static member inline RemoveFieldsByJsonPath(conn, tableName, jsonPath, fieldNames) = RemoveFields.byJsonPath tableName jsonPath fieldNames (Sql.existingConnection conn) ///

Delete a document by its ID

/// The NpgsqlConnection on which to run the query /// The table in which a document should be deleted (may include schema) /// The ID of the document to delete [] static member inline DeleteById(conn, tableName, docId: 'TKey) = Delete.byId tableName docId (Sql.existingConnection conn) ///

Delete documents by matching a JSON field comparison query (->> =, etc.)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be deleted (may include schema) /// Whether to match any or all of the field conditions /// The field conditions to match [] static member inline DeleteByFields(conn, tableName, howMatched, fields) = Delete.byFields tableName howMatched fields (Sql.existingConnection conn) ///

Delete documents by matching a JSON contains query (@>)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be deleted (may include schema) /// The document to match the containment query [] static member inline DeleteByContains(conn, tableName, criteria: 'TContains) = Delete.byContains tableName criteria (Sql.existingConnection conn) ///

Delete documents by matching a JSON Path match query (@?)

/// The NpgsqlConnection on which to run the query /// The table in which documents should be deleted (may include schema) /// The JSON Path expression to match [] static member inline DeleteByJsonPath(conn, tableName, jsonPath) = Delete.byJsonPath tableName jsonPath (Sql.existingConnection conn)