245 lines
8.9 KiB
Kotlin
245 lines
8.9 KiB
Kotlin
package solutions.bitbadger.documents
|
|
|
|
import java.sql.Connection
|
|
import java.sql.ResultSet
|
|
|
|
// ~~~ CUSTOM QUERIES ~~~
|
|
|
|
/**
|
|
* Execute a query that returns a list of results
|
|
*
|
|
* @param query The query to retrieve the results
|
|
* @param parameters Parameters to use for the query
|
|
* @param mapFunc The mapping function between the document and the domain item
|
|
* @return A list of results for the given query
|
|
*/
|
|
inline fun <reified TDoc> Connection.customList(
|
|
query: String, parameters: Collection<Parameter<*>> = listOf(), mapFunc: (ResultSet) -> TDoc
|
|
) = Custom.list(query, parameters, this, mapFunc)
|
|
|
|
/**
|
|
* Execute a query that returns one or no results
|
|
*
|
|
* @param query The query to retrieve the results
|
|
* @param parameters Parameters to use for the query
|
|
* @param mapFunc The mapping function between the document and the domain item
|
|
* @return The document if one matches the query, `null` otherwise
|
|
*/
|
|
inline fun <reified TDoc> Connection.customSingle(
|
|
query: String, parameters: Collection<Parameter<*>> = listOf(), mapFunc: (ResultSet) -> TDoc
|
|
) = Custom.single(query, parameters, this, mapFunc)
|
|
|
|
/**
|
|
* Execute a query that returns no results
|
|
*
|
|
* @param query The query to retrieve the results
|
|
* @param parameters Parameters to use for the query
|
|
*/
|
|
fun Connection.customNonQuery(query: String, parameters: Collection<Parameter<*>> = listOf()) =
|
|
Custom.nonQuery(query, parameters, this)
|
|
|
|
/**
|
|
* Execute a query that returns a scalar result
|
|
*
|
|
* @param query The query to retrieve the result
|
|
* @param parameters Parameters to use for the query
|
|
* @param mapFunc The mapping function between the document and the domain item
|
|
* @return The scalar value from the query
|
|
*/
|
|
inline fun <reified T> Connection.customScalar(
|
|
query: String,
|
|
parameters: Collection<Parameter<*>> = listOf(),
|
|
mapFunc: (ResultSet) -> T & Any
|
|
) = Custom.scalar(query, parameters, this, mapFunc)
|
|
|
|
// ~~~ DEFINITION QUERIES ~~~
|
|
|
|
/**
|
|
* Create a document table if necessary
|
|
*
|
|
* @param tableName The table whose existence should be ensured (may include schema)
|
|
*/
|
|
fun Connection.ensureTable(tableName: String) =
|
|
Definition.ensureTable(tableName, this)
|
|
|
|
/**
|
|
* Create an index on field(s) within documents in the specified table if necessary
|
|
*
|
|
* @param tableName The table to be indexed (may include schema)
|
|
* @param indexName The name of the index to create
|
|
* @param fields One or more fields to be indexed<
|
|
*/
|
|
fun Connection.ensureFieldIndex(tableName: String, indexName: String, fields: Collection<String>) =
|
|
Definition.ensureFieldIndex(tableName, indexName, fields, this)
|
|
|
|
/**
|
|
* Create a document index on a table (PostgreSQL only)
|
|
*
|
|
* @param tableName The table to be indexed (may include schema)
|
|
* @param indexType The type of index to ensure
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
fun Connection.ensureDocumentIndex(tableName: String, indexType: DocumentIndex) =
|
|
Definition.ensureDocumentIndex(tableName, indexType, this)
|
|
|
|
// ~~~ DOCUMENT MANIPULATION QUERIES ~~~
|
|
|
|
/**
|
|
* Insert a new document
|
|
*
|
|
* @param tableName The table into which the document should be inserted (may include schema)
|
|
* @param document The document to be inserted
|
|
*/
|
|
inline fun <reified TDoc> Connection.insert(tableName: String, document: TDoc) =
|
|
Document.insert(tableName, document, this)
|
|
|
|
// ~~~ DOCUMENT COUNT QUERIES ~~~
|
|
|
|
/**
|
|
* Count all documents in the table
|
|
*
|
|
* @param tableName The name of the table in which documents should be counted
|
|
* @return A count of the documents in the table
|
|
*/
|
|
fun Connection.countAll(tableName: String) =
|
|
Count.all(tableName, this)
|
|
|
|
/**
|
|
* Count documents using a field comparison
|
|
*
|
|
* @param tableName The name of the table in which documents should be counted
|
|
* @param fields The fields which should be compared
|
|
* @param howMatched How the fields should be matched
|
|
* @return A count of the matching documents in the table
|
|
*/
|
|
fun Connection.countByFields(tableName: String, fields: Collection<Field<*>>, howMatched: FieldMatch? = null) =
|
|
Count.byFields(tableName, fields, howMatched, this)
|
|
|
|
/**
|
|
* Count documents using a JSON containment query (PostgreSQL only)
|
|
*
|
|
* @param tableName The name of the table in which documents should be counted
|
|
* @param criteria The object for which JSON containment should be checked
|
|
* @return A count of the matching documents in the table
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
inline fun <reified T> Connection.countByContains(tableName: String, criteria: T) =
|
|
Count.byContains(tableName, criteria, this)
|
|
|
|
/**
|
|
* Count documents using a JSON Path match query (PostgreSQL only)
|
|
*
|
|
* @param tableName The name of the table in which documents should be counted
|
|
* @param path The JSON path comparison to match
|
|
* @return A count of the matching documents in the table
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
fun Connection.countByJsonPath(tableName: String, path: String) =
|
|
Count.byJsonPath(tableName, path, this)
|
|
|
|
// ~~~ DOCUMENT EXISTENCE QUERIES ~~~
|
|
|
|
/**
|
|
* Determine a document's existence by its ID
|
|
*
|
|
* @param tableName The name of the table in which document existence should be checked
|
|
* @param docId The ID of the document to be checked
|
|
* @return True if the document exists, false if not
|
|
*/
|
|
fun <TKey> Connection.existsById(tableName: String, docId: TKey) =
|
|
Exists.byId(tableName, docId, this)
|
|
|
|
/**
|
|
* Determine document existence using a field comparison
|
|
*
|
|
* @param tableName The name of the table in which document existence should be checked
|
|
* @param fields The fields which should be compared
|
|
* @param howMatched How the fields should be matched
|
|
* @return True if any matching documents exist, false if not
|
|
*/
|
|
fun Connection.existsByFields(tableName: String, fields: Collection<Field<*>>, howMatched: FieldMatch? = null) =
|
|
Exists.byFields(tableName, fields, howMatched, this)
|
|
|
|
/**
|
|
* Determine document existence using a JSON containment query (PostgreSQL only)
|
|
*
|
|
* @param tableName The name of the table in which document existence should be checked
|
|
* @param criteria The object for which JSON containment should be checked
|
|
* @return True if any matching documents exist, false if not
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
inline fun <reified T> Connection.existsByContains(tableName: String, criteria: T) =
|
|
Exists.byContains(tableName, criteria, this)
|
|
|
|
/**
|
|
* Determine document existence using a JSON Path match query (PostgreSQL only)
|
|
*
|
|
* @param tableName The name of the table in which document existence should be checked
|
|
* @param path The JSON path comparison to match
|
|
* @return True if any matching documents exist, false if not
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
fun Connection.existsByJsonPath(tableName: String, path: String) =
|
|
Exists.byJsonPath(tableName, path, this)
|
|
|
|
// ~~~ DOCUMENT RETRIEVAL QUERIES ~~~
|
|
|
|
/**
|
|
* Retrieve all documents in the given table
|
|
*
|
|
* @param tableName The table from which documents should be retrieved
|
|
* @return A list of documents from the given table
|
|
*/
|
|
inline fun <reified TDoc> Connection.findAll(tableName: String) =
|
|
Find.all<TDoc>(tableName, this)
|
|
|
|
/**
|
|
* Retrieve all documents in the given table
|
|
*
|
|
* @param tableName The table from which documents should be retrieved
|
|
* @return A list of documents from the given table
|
|
*/
|
|
inline fun <reified TDoc> Connection.findAll(tableName: String, orderBy: Collection<Field<*>>) =
|
|
Find.all<TDoc>(tableName, orderBy, this)
|
|
|
|
// ~~~ DOCUMENT DELETION QUERIES ~~~
|
|
|
|
/**
|
|
* Delete a document by its ID
|
|
*
|
|
* @param tableName The name of the table from which documents should be deleted
|
|
* @param docId The ID of the document to be deleted
|
|
*/
|
|
fun <TKey> Connection.deleteById(tableName: String, docId: TKey) =
|
|
Delete.byId(tableName, docId, this)
|
|
|
|
/**
|
|
* Delete documents using a field comparison
|
|
*
|
|
* @param tableName The name of the table from which documents should be deleted
|
|
* @param fields The fields which should be compared
|
|
* @param howMatched How the fields should be matched
|
|
*/
|
|
fun Connection.deleteByFields(tableName: String, fields: Collection<Field<*>>, howMatched: FieldMatch? = null) =
|
|
Delete.byFields(tableName, fields, howMatched, this)
|
|
|
|
/**
|
|
* Delete documents using a JSON containment query (PostgreSQL only)
|
|
*
|
|
* @param tableName The name of the table from which documents should be deleted
|
|
* @param criteria The object for which JSON containment should be checked
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
inline fun <reified T> Connection.deleteByContains(tableName: String, criteria: T) =
|
|
Delete.byContains(tableName, criteria, this)
|
|
|
|
/**
|
|
* Delete documents using a JSON Path match query (PostgreSQL only)
|
|
*
|
|
* @param tableName The name of the table from which documents should be deleted
|
|
* @param path The JSON path comparison to match
|
|
* @throws DocumentException If called on a SQLite connection
|
|
*/
|
|
fun Connection.deleteByJsonPath(tableName: String, path: String) =
|
|
Delete.byJsonPath(tableName, path, this)
|