bit-badger/solutions.bitbadger.documents
1
0
Fork 0
Code Issues Pull Requests Packages Releases 1 Activity

Add Scala Json wrapper

Browse Source
This commit is contained in:
Daniel J. Summers 2025-03-29 17:08:12 -04:00
parent 4e6cfa35a7
commit 53dd31b913
4 changed files with 470 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/core/src/main/kotlin/java/Json.kt
View File

@ -26,7 +26,7 @@ object Json {
Custom.jsonArray(FindQuery.all(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(), conn, Results::jsonFromData)
/**
* Retrieve all documents in the given table
* Retrieve all documents in the given table (creates connection)
*
* @param tableName The table from which documents should be retrieved
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
@ -72,7 +72,7 @@ object Json {
)
/**
* Retrieve a document by its ID
* Retrieve a document by its ID (creates connection)
*
* @param tableName The table from which the document should be retrieved
* @param docId The ID of the document to retrieve
@ -114,7 +114,7 @@ object Json {
}
/**
* Retrieve documents using a field comparison, ordering results by the given fields
* Retrieve documents using a field comparison, ordering results by the given fields (creates connection)
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
@ -177,7 +177,8 @@ object Json {
)
/**
* Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only)
* Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
@ -226,7 +227,8 @@ object Json {
)
/**
* Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only)
* Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
@ -284,7 +286,7 @@ object Json {
}
/**
* Retrieve the first document using a field comparison and optional ordering fields
* Retrieve the first document using a field comparison and optional ordering fields (creates connection)
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
@ -361,7 +363,8 @@ object Json {
firstByContains(tableName, criteria, null, conn)
/**
* Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only)
* Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
@ -410,7 +413,8 @@ object Json {
firstByJsonPath(tableName, path, null, conn)
/**
* Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only)
* Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match

16
src/scala/src/main/scala/Find.scala
View File

@ -44,7 +44,7 @@ object Find:
* @return A list of documents from the given table
* @throws DocumentException If no connection string has been set, or if query execution fails
*/
def all[Doc](tableName: String, orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
def all[Doc](tableName: String, orderBy: Seq[Field[?]] = Nil)(using tag: ClassTag[Doc]): List[Doc] =
Using(Configuration.dbConn()) { conn => all[Doc](tableName, orderBy, conn) }.get
/**
@ -61,7 +61,7 @@ object Find:
Parameters.addFields(Field.equal(Configuration.idField, docId, ":id") :: Nil).toSeq, conn, Results.fromData)
/**
* Retrieve a document by its ID (creates connection
* Retrieve a document by its ID (creates connection)
*
* @param tableName The table from which the document should be retrieved
* @param docId The ID of the document to retrieve
@ -128,7 +128,7 @@ object Find:
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
def byFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
orderBy: Seq[Field[?]] = Nil)(using tag: ClassTag[Doc]): List[Doc] =
Using(Configuration.dbConn()) { conn => byFields[Doc](tableName, fields, howMatched, orderBy, conn) }.get
/**
@ -168,7 +168,7 @@ object Find:
* @return A list of documents matching the JSON containment query
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def byContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
def byContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): List[Doc] =
Using(Configuration.dbConn()) { conn => byContains[Doc, A](tableName, criteria, orderBy, conn) }.get
@ -209,7 +209,7 @@ object Find:
* @return A list of documents matching the JSON Path match query
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def byJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
def byJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): List[Doc] =
Using(Configuration.dbConn()) { conn => byJsonPath[Doc](tableName, path, orderBy, conn) }.get
@ -283,7 +283,7 @@ object Find:
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
def firstByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): Option[Doc] =
orderBy: Seq[Field[?]] = Nil)(using tag: ClassTag[Doc]): Option[Doc] =
Using(Configuration.dbConn()) { conn => firstByFields[Doc](tableName, fields, howMatched, orderBy, conn) }.get
/**
@ -323,7 +323,7 @@ object Find:
* @return An `Option` with the first document matching the JSON containment query if found
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def firstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
def firstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): Option[Doc] =
Using(Configuration.dbConn()) { conn => firstByContains[Doc, A](tableName, criteria, orderBy, conn) }.get
@ -364,6 +364,6 @@ object Find:
* @return An `Optional` item, with the first document matching the JSON Path match query if found
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def firstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
def firstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): Option[Doc] =
Using(Configuration.dbConn()) { conn => firstByJsonPath[Doc](tableName, path, orderBy, conn) }.get

341
src/scala/src/main/scala/Json.scala Normal file
View File

@ -0,0 +1,341 @@
package solutions.bitbadger.documents.scala
import solutions.bitbadger.documents.{Field, FieldMatch}
import solutions.bitbadger.documents.java.Json as CoreJson
import java.sql.Connection
import _root_.scala.jdk.CollectionConverters.*
object Json:
/**
* Retrieve all documents in the given table, ordering results by the optional given fields
*
* @param tableName The table from which documents should be retrieved
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents from the given table
* @throws DocumentException If query execution fails
*/
def all(tableName: String, orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.all(tableName, orderBy.asJava, conn)
/**
* Retrieve all documents in the given table, ordering results by the optional given fields
*
* @param tableName The table from which documents should be retrieved
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents from the given table
* @throws DocumentException If query execution fails
*/
def all(tableName: String, conn: Connection): String =
CoreJson.all(tableName, conn)
/**
* Retrieve all documents in the given table (creates connection)
*
* @param tableName The table from which documents should be retrieved
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents from the given table
* @throws DocumentException If no connection string has been set, or if query execution fails
*/
def all(tableName: String, orderBy: Seq[Field[?]] = Nil): String =
CoreJson.all(tableName, orderBy.asJava)
/**
* Retrieve a document by its ID
*
* @param tableName The table from which the document should be retrieved
* @param docId The ID of the document to retrieve
* @param conn The connection over which documents should be retrieved
* @return A JSON document if found, an empty JSON object if not found
* @throws DocumentException If no dialect has been configured
*/
def byId[Key](tableName: String, docId: Key, conn: Connection): String =
CoreJson.byId(tableName, docId, conn)
/**
* Retrieve a document by its ID (creates connection)
*
* @param tableName The table from which the document should be retrieved
* @param docId The ID of the document to retrieve
* @return A JSON document if found, an empty JSON object if not found
* @throws DocumentException If no connection string has been set
*/
def byId[Key](tableName: String, docId: Key): String =
CoreJson.byId(tableName, docId)
/**
* Retrieve documents using a field comparison, ordering results by the given fields
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the field comparison
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def byFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], orderBy: Seq[Field[?]],
conn: Connection): String =
CoreJson.byFields(tableName, fields.asJava, howMatched.orNull, orderBy.asJava, conn)
/**
* Retrieve documents using a field comparison
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the field comparison
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def byFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], conn: Connection): String =
CoreJson.byFields(tableName, fields.asJava, howMatched.orNull, conn)
/**
* Retrieve documents using a field comparison, ordering results by the given fields
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the field comparison
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def byFields(tableName: String, fields: Seq[Field[?]], orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.byFields(tableName, fields.asJava, null, orderBy.asJava, conn)
/**
* Retrieve documents using a field comparison, ordering results by the given fields (creates connection)
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents matching the field comparison
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
def byFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = Nil): String =
CoreJson.byFields(tableName, fields.asJava, howMatched.orNull, orderBy.asJava)
/**
* Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the JSON containment query
* @throws DocumentException If called on a SQLite connection
*/
def byContains[A](tableName: String, criteria: A, orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.byContains(tableName, criteria, orderBy.asJava, conn)
/**
* Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the JSON containment query
* @throws DocumentException If called on a SQLite connection
*/
def byContains[A](tableName: String, criteria: A, conn: Connection): String =
CoreJson.byContains(tableName, criteria, conn)
/**
* Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents matching the JSON containment query
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def byContains[A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil): String =
CoreJson.byContains(tableName, criteria, orderBy.asJava)
/**
* Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the JSON Path match query
* @throws DocumentException If called on a SQLite connection
*/
def byJsonPath(tableName: String, path: String, orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.byJsonPath(tableName, path, orderBy.asJava, conn)
/**
* Retrieve documents using a JSON Path match query (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param conn The connection over which documents should be retrieved
* @return A JSON array of documents matching the JSON Path match query
* @throws DocumentException If called on a SQLite connection
*/
def byJsonPath(tableName: String, path: String, conn: Connection): String =
CoreJson.byJsonPath(tableName, path, conn)
/**
* Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents matching the JSON Path match query
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def byJsonPath(tableName: String, path: String, orderBy: Seq[Field[?]] = Nil): String =
CoreJson.byJsonPath(tableName, path, orderBy.asJava)
/**
* Retrieve the first document using a field comparison and ordering fields
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the field comparison if found, an empty JSON object otherwise
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def firstByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], orderBy: Seq[Field[?]],
conn: Connection): String =
CoreJson.firstByFields(tableName, fields.asJava, howMatched.orNull, orderBy.asJava, conn)
/**
* Retrieve the first document using a field comparison
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the field comparison if found, an empty JSON object otherwise
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def firstByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch],
conn: Connection): String =
CoreJson.firstByFields(tableName, fields.asJava, howMatched.orNull, conn)
/**
* Retrieve the first document using a field comparison and ordering fields
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the field comparison if found, an empty JSON object otherwise
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def firstByFields(tableName: String, fields: Seq[Field[?]], orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.firstByFields(tableName, fields.asJava, null, orderBy.asJava, conn)
/**
* Retrieve the first document using a field comparison
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the field comparison if found, an empty JSON object otherwise
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def firstByFields(tableName: String, fields: Seq[Field[?]], conn: Connection): String =
CoreJson.firstByFields(tableName, fields.asJava, null, conn)
/**
* Retrieve the first document using a field comparison and optional ordering fields (creates connection)
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first JSON document matching the field comparison if found, an empty JSON object otherwise
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
def firstByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = Nil): String =
CoreJson.firstByFields(tableName, fields.asJava, howMatched.orNull, orderBy.asJava)
/**
* Retrieve the first document using a JSON containment query and ordering fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the JSON containment query if found, an empty JSON object otherwise
* @throws DocumentException If called on a SQLite connection
*/
def firstByContains[A](tableName: String, criteria: A, orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.firstByContains(tableName, criteria, orderBy.asJava, conn)
/**
* Retrieve the first document using a JSON containment query (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the JSON containment query if found, an empty JSON object otherwise
* @throws DocumentException If called on a SQLite connection
*/
def firstByContains[A](tableName: String, criteria: A, conn: Connection): String =
CoreJson.firstByContains(tableName, criteria, conn)
/**
* Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first JSON document matching the JSON containment query if found, an empty JSON object otherwise
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def firstByContains[A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil): String =
CoreJson.firstByContains(tableName, criteria, orderBy.asJava)
/**
* Retrieve the first document using a JSON Path match query and ordering fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the JSON Path match query if found, an empty JSON object otherwise
* @throws DocumentException If called on a SQLite connection
*/
def firstByJsonPath(tableName: String, path: String, orderBy: Seq[Field[?]], conn: Connection): String =
CoreJson.firstByJsonPath(tableName, path, orderBy.asJava, conn)
/**
* Retrieve the first document using a JSON Path match query (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param conn The connection over which documents should be retrieved
* @return The first JSON document matching the JSON Path match query if found, an empty JSON object otherwise
* @throws DocumentException If called on a SQLite connection
*/
def firstByJsonPath(tableName: String, path: String, conn: Connection): String =
CoreJson.firstByJsonPath(tableName, path, conn)
/**
* Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only; creates
* connection)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first JSON document matching the JSON Path match query if found, an empty JSON object otherwise
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def firstByJsonPath(tableName: String, path: String, orderBy: Seq[Field[?]] = Nil): String =
CoreJson.firstByJsonPath(tableName, path, orderBy.asJava)

118
src/scala/src/main/scala/extensions/package.scala
View File

@ -113,7 +113,7 @@ extension (conn: Connection)
* @param parameters Parameters to use for the query
* @throws DocumentException If parameters are invalid
*/
def customNonQuery(query: String, parameters: Seq[Parameter[?]] = List()): Unit =
def customNonQuery(query: String, parameters: Seq[Parameter[?]] = Nil): Unit =
Custom.nonQuery(query, parameters, conn)
/**
@ -298,7 +298,7 @@ extension (conn: Connection)
def existsByJsonPath(tableName: String, path: String): Boolean =
Exists.byJsonPath(tableName, path, conn)
// ~~~ DOCUMENT RETRIEVAL QUERIES ~~~
// ~~~ DOCUMENT RETRIEVAL QUERIES (Domain Objects) ~~~
/**
* Retrieve all documents in the given table, ordering results by the optional given fields
@ -308,7 +308,7 @@ extension (conn: Connection)
* @return A list of documents from the given table
* @throws DocumentException If query execution fails
*/
def findAll[Doc](tableName: String, orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
def findAll[Doc](tableName: String, orderBy: Seq[Field[?]] = Nil)(using tag: ClassTag[Doc]): List[Doc] =
Find.all[Doc](tableName, orderBy, conn)
/**
@ -333,7 +333,7 @@ extension (conn: Connection)
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def findByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
orderBy: Seq[Field[?]] = Nil)(using tag: ClassTag[Doc]): List[Doc] =
Find.byFields[Doc](tableName, fields, howMatched, orderBy, conn)
/**
@ -346,7 +346,7 @@ extension (conn: Connection)
* @return A list of documents matching the JSON containment query
* @throws DocumentException If called on a SQLite connection
*/
def findByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
def findByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): List[Doc] =
Find.byContains[Doc, A](tableName, criteria, orderBy, conn)
@ -359,7 +359,7 @@ extension (conn: Connection)
* @return A list of documents matching the JSON Path match query
* @throws DocumentException If called on a SQLite connection
*/
def findByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
def findByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): List[Doc] =
Find.byJsonPath[Doc](tableName, path, orderBy, conn)
@ -374,7 +374,7 @@ extension (conn: Connection)
* @throws DocumentException If no dialect has been configured, or if parameters are invalid
*/
def findFirstByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): Option[Doc] =
orderBy: Seq[Field[?]] = Nil)(using tag: ClassTag[Doc]): Option[Doc] =
Find.firstByFields[Doc](tableName, fields, howMatched, orderBy, conn)
/**
@ -386,7 +386,7 @@ extension (conn: Connection)
* @return The first document matching the JSON containment query, or `None` if no matches are found
* @throws DocumentException If called on a SQLite connection
*/
def findFirstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
def findFirstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): Option[Doc] =
Find.firstByContains[Doc, A](tableName, criteria, orderBy, conn)
@ -399,10 +399,110 @@ extension (conn: Connection)
* @return The first document matching the JSON Path match query, or `None` if no matches are found
* @throws DocumentException If called on a SQLite connection
*/
def findFirstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
def findFirstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = Nil)
(using tag: ClassTag[Doc]): Option[Doc] =
Find.firstByJsonPath[Doc](tableName, path, orderBy, conn)
// ~~~ DOCUMENT RETRIEVAL QUERIES (Raw JSON) ~~~
/**
* Retrieve all documents in the given table
*
* @param tableName The table from which documents should be retrieved
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents from the given table
* @throws DocumentException If no connection string has been set, or if query execution fails
*/
def jsonAll(tableName: String, orderBy: Seq[Field[?]] = Nil): String =
Json.all(tableName, orderBy, conn)
/**
* Retrieve a document by its ID
*
* @param tableName The table from which the document should be retrieved
* @param docId The ID of the document to retrieve
* @return A JSON document if found, an empty JSON object if not found
* @throws DocumentException If no connection string has been set
*/
def jsonById[Key](tableName: String, docId: Key): String =
Json.byId(tableName, docId, conn)
/**
* Retrieve documents using a field comparison, ordering results by the given fields
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents matching the field comparison
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
def jsonByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = Nil): String =
Json.byFields(tableName, fields, howMatched, orderBy, conn)
/**
* Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents matching the JSON containment query
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def jsonByContains[A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil): String =
Json.byContains(tableName, criteria, orderBy, conn)
/**
* Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return A JSON array of documents matching the JSON Path match query
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def jsonByJsonPath(tableName: String, path: String, orderBy: Seq[Field[?]] = Nil): String =
Json.byJsonPath(tableName, path, orderBy, conn)
/**
* Retrieve the first document using a field comparison and optional ordering fields
*
* @param tableName The table from which documents should be retrieved
* @param fields The fields which should be compared
* @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first JSON document matching the field comparison if found, an empty JSON object otherwise
* @throws DocumentException If no connection string has been set, or if parameters are invalid
*/
def jsonFirstByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
orderBy: Seq[Field[?]] = Nil): String =
Json.firstByFields(tableName, fields, howMatched, orderBy, conn)
/**
* Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param criteria The object for which JSON containment should be checked
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first JSON document matching the JSON containment query if found, an empty JSON object otherwise
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def jsonFirstByContains[A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = Nil): String =
Json.firstByContains(tableName, criteria, orderBy, conn)
/**
* Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only)
*
* @param tableName The table from which documents should be retrieved
* @param path The JSON path comparison to match
* @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
* @return The first JSON document matching the JSON Path match query if found, an empty JSON object otherwise
* @throws DocumentException If no connection string has been set, or if called on a SQLite connection
*/
def jsonFirstByJsonPath(tableName: String, path: String, orderBy: Seq[Field[?]] = Nil): String =
Json.firstByJsonPath(tableName, path, orderBy, conn)
// ~~~ DOCUMENT PATCH (PARTIAL UPDATE) QUERIES ~~~
/**