diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 1106a32..afb5348 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -6,11 +6,13 @@ - + + + diff --git a/.idea/encodings.xml b/.idea/encodings.xml index e48c513..2afc1f9 100644 --- a/.idea/encodings.xml +++ b/.idea/encodings.xml @@ -1,9 +1,15 @@ + + + + + + \ No newline at end of file diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml index bb44937..c22b6fa 100644 --- a/.idea/kotlinc.xml +++ b/.idea/kotlinc.xml @@ -1,6 +1,6 @@ - \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index 724dd10..0000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/pom.xml b/pom.xml index 3f86db7..6871788 100644 --- a/pom.xml +++ b/pom.xml @@ -43,125 +43,8 @@ 1.8.0 - - - - src/main/kotlin - src/test/kotlin - - - org.jetbrains.kotlin - kotlin-maven-plugin - ${kotlin.version} - - - compile - process-sources - - compile - - - - test-compile - test-compile - - test-compile - - - - - - kotlinx-serialization - - - - - org.jetbrains.kotlin - kotlin-maven-serialization - ${kotlin.version} - - - - - maven-surefire-plugin - 2.22.2 - - - maven-failsafe-plugin - 2.22.2 - - - - integration-test - verify - - - - - - org.codehaus.mojo - exec-maven-plugin - 1.6.0 - - MainKt - - - - org.apache.maven.plugins - maven-compiler-plugin - - 9 - 9 - - - - - - - - org.junit.jupiter - junit-jupiter - 5.11.1 - test - - - org.jetbrains.kotlin - kotlin-test-junit5 - ${kotlin.version} - test - - - org.jetbrains.kotlin - kotlin-stdlib - ${kotlin.version} - - - org.jetbrains.kotlin - kotlin-reflect - ${kotlin.version} - - - org.jetbrains.kotlinx - kotlinx-serialization-json - ${serialization.version} - - - org.xerial - sqlite-jdbc - 3.46.1.2 - test - - - org.postgresql - postgresql - 42.7.5 - test - - + + src + \ No newline at end of file diff --git a/src/jvm/src/main/kotlin/extensions/Connection.kt b/src/jvm/src/main/kotlin/extensions/Connection.kt index 97c44ab..8c4267a 100644 --- a/src/jvm/src/main/kotlin/extensions/Connection.kt +++ b/src/jvm/src/main/kotlin/extensions/Connection.kt @@ -24,7 +24,7 @@ fun Connection.customList( clazz: Class, mapFunc: (ResultSet, Class) -> TDoc ) = - solutions.bitbadger.documents.jvm.Custom.list(query, parameters, clazz, this, mapFunc) + Custom.list(query, parameters, clazz, this, mapFunc) /** * Execute a query that returns one or no results @@ -41,7 +41,7 @@ fun Connection.customSingle( clazz: Class, mapFunc: (ResultSet, Class) -> TDoc ) = - solutions.bitbadger.documents.jvm.Custom.single(query, parameters, clazz, this, mapFunc) + Custom.single(query, parameters, clazz, this, mapFunc) /** * Execute a query that returns no results @@ -50,7 +50,7 @@ fun Connection.customSingle( * @param parameters Parameters to use for the query */ fun Connection.customNonQuery(query: String, parameters: Collection> = listOf()) = - solutions.bitbadger.documents.jvm.Custom.nonQuery(query, parameters, this) + Custom.nonQuery(query, parameters, this) /** * Execute a query that returns a scalar result @@ -67,7 +67,7 @@ fun Connection.customScalar( clazz: Class, mapFunc: (ResultSet, Class) -> T ) = - solutions.bitbadger.documents.jvm.Custom.scalar(query, parameters, clazz, this, mapFunc) + Custom.scalar(query, parameters, clazz, this, mapFunc) // ~~~ DEFINITION QUERIES ~~~ @@ -109,7 +109,7 @@ fun Connection.ensureDocumentIndex(tableName: String, indexType: DocumentIndex) * @param document The document to be inserted */ fun Connection.insert(tableName: String, document: TDoc) = - Document.insert(tableName, document, this) + Document.insert(tableName, document, this) /** * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert") @@ -149,6 +149,7 @@ fun Connection.countAll(tableName: String) = * @param howMatched How the fields should be matched * @return A count of the matching documents in the table */ +@JvmOverloads fun Connection.countByFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = Count.byFields(tableName, fields, howMatched, this) @@ -196,6 +197,7 @@ fun Connection.existsById(tableName: String, docId: TKey) = * @param howMatched How the fields should be matched * @return True if any matching documents exist, false if not */ +@JvmOverloads fun Connection.existsByFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = Exists.byFields(tableName, fields, howMatched, this) @@ -499,6 +501,7 @@ fun Connection.deleteById(tableName: String, docId: TKey) = * @param fields The fields which should be compared * @param howMatched How the fields should be matched */ +@JvmOverloads fun Connection.deleteByFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = Delete.byFields(tableName, fields, howMatched, this) diff --git a/src/jvm/src/main/kotlin/jvm/Count.kt b/src/jvm/src/main/kotlin/jvm/Count.kt index 94ced3a..1127d80 100644 --- a/src/jvm/src/main/kotlin/jvm/Count.kt +++ b/src/jvm/src/main/kotlin/jvm/Count.kt @@ -1,7 +1,7 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.* -import solutions.bitbadger.documents.query.Count +import solutions.bitbadger.documents.query.CountQuery import solutions.bitbadger.documents.extensions.customScalar import java.sql.Connection @@ -19,7 +19,7 @@ object Count { */ @JvmStatic fun all(tableName: String, conn: Connection) = - conn.customScalar(Count.all(tableName), listOf(), Long::class.java, Results::toCount) + conn.customScalar(CountQuery.all(tableName), listOf(), Long::class.java, Results::toCount) /** * Count all documents in the table @@ -50,7 +50,7 @@ object Count { ): Long { val named = Parameters.nameFields(fields) return conn.customScalar( - Count.byFields(tableName, named, howMatched), + CountQuery.byFields(tableName, named, howMatched), Parameters.addFields(named), Long::class.java, Results::toCount @@ -82,7 +82,7 @@ object Count { @JvmStatic fun byContains(tableName: String, criteria: TContains, conn: Connection) = conn.customScalar( - Count.byContains(tableName), + CountQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), Long::class.java, Results::toCount @@ -112,7 +112,7 @@ object Count { @JvmStatic fun byJsonPath(tableName: String, path: String, conn: Connection) = conn.customScalar( - Count.byJsonPath(tableName), + CountQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path)), Long::class.java, Results::toCount diff --git a/src/jvm/src/main/kotlin/jvm/Definition.kt b/src/jvm/src/main/kotlin/jvm/Definition.kt index 7946838..8e18818 100644 --- a/src/jvm/src/main/kotlin/jvm/Definition.kt +++ b/src/jvm/src/main/kotlin/jvm/Definition.kt @@ -4,7 +4,7 @@ import solutions.bitbadger.documents.Configuration import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.DocumentIndex import solutions.bitbadger.documents.extensions.customNonQuery -import solutions.bitbadger.documents.query.Definition +import solutions.bitbadger.documents.query.DefinitionQuery import java.sql.Connection /** @@ -21,8 +21,8 @@ object Definition { @JvmStatic fun ensureTable(tableName: String, conn: Connection) = Configuration.dialect("ensure $tableName exists").let { - conn.customNonQuery(Definition.ensureTable(tableName, it)) - conn.customNonQuery(Definition.ensureKey(tableName, it)) + conn.customNonQuery(DefinitionQuery.ensureTable(tableName, it)) + conn.customNonQuery(DefinitionQuery.ensureKey(tableName, it)) } /** @@ -44,7 +44,7 @@ object Definition { */ @JvmStatic fun ensureFieldIndex(tableName: String, indexName: String, fields: Collection, conn: Connection) = - conn.customNonQuery(Definition.ensureIndexOn(tableName, indexName, fields)) + conn.customNonQuery(DefinitionQuery.ensureIndexOn(tableName, indexName, fields)) /** * Create an index on field(s) within documents in the specified table if necessary @@ -68,7 +68,7 @@ object Definition { @Throws(DocumentException::class) @JvmStatic fun ensureDocumentIndex(tableName: String, indexType: DocumentIndex, conn: Connection) = - conn.customNonQuery(Definition.ensureDocumentIndexOn(tableName, indexType)) + conn.customNonQuery(DefinitionQuery.ensureDocumentIndexOn(tableName, indexType)) /** * Create a document index on a table (PostgreSQL only) diff --git a/src/jvm/src/main/kotlin/jvm/Delete.kt b/src/jvm/src/main/kotlin/jvm/Delete.kt index 9715698..d442d7f 100644 --- a/src/jvm/src/main/kotlin/jvm/Delete.kt +++ b/src/jvm/src/main/kotlin/jvm/Delete.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.* import solutions.bitbadger.documents.extensions.customNonQuery -import solutions.bitbadger.documents.query.Delete +import solutions.bitbadger.documents.query.DeleteQuery import java.sql.Connection /** @@ -20,7 +20,7 @@ object Delete { @JvmStatic fun byId(tableName: String, docId: TKey, conn: Connection) = conn.customNonQuery( - Delete.byId(tableName, docId), + DeleteQuery.byId(tableName, docId), Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))) ) @@ -46,7 +46,7 @@ object Delete { @JvmOverloads fun byFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null, conn: Connection) { val named = Parameters.nameFields(fields) - conn.customNonQuery(Delete.byFields(tableName, named, howMatched), Parameters.addFields(named)) + conn.customNonQuery(DeleteQuery.byFields(tableName, named, howMatched), Parameters.addFields(named)) } /** @@ -72,7 +72,7 @@ object Delete { @Throws(DocumentException::class) @JvmStatic fun byContains(tableName: String, criteria: TContains, conn: Connection) = - conn.customNonQuery(Delete.byContains(tableName), listOf(Parameters.json(":criteria", criteria))) + conn.customNonQuery(DeleteQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria))) /** * Delete documents using a JSON containment query (PostgreSQL only) @@ -97,7 +97,7 @@ object Delete { @Throws(DocumentException::class) @JvmStatic fun byJsonPath(tableName: String, path: String, conn: Connection) = - conn.customNonQuery(Delete.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path))) + conn.customNonQuery(DeleteQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path))) /** * Delete documents using a JSON Path match query (PostgreSQL only) diff --git a/src/jvm/src/main/kotlin/jvm/Document.kt b/src/jvm/src/main/kotlin/jvm/Document.kt index ba7faac..7b2e0eb 100644 --- a/src/jvm/src/main/kotlin/jvm/Document.kt +++ b/src/jvm/src/main/kotlin/jvm/Document.kt @@ -2,10 +2,9 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.AutoId import solutions.bitbadger.documents.Configuration -import solutions.bitbadger.documents.Dialect import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.extensions.customNonQuery -import solutions.bitbadger.documents.query.Document +import solutions.bitbadger.documents.query.DocumentQuery import solutions.bitbadger.documents.query.Where import solutions.bitbadger.documents.query.statementWhere import java.sql.Connection @@ -25,35 +24,10 @@ object Document { @JvmStatic fun insert(tableName: String, document: TDoc, conn: Connection) { val strategy = Configuration.autoIdStrategy - val query = if (strategy == AutoId.DISABLED) { - Document.insert(tableName) + val query = if (strategy == AutoId.DISABLED || !AutoId.needsAutoId(strategy, document, Configuration.idField)) { + DocumentQuery.insert(tableName) } else { - val idField = Configuration.idField - val dialect = Configuration.dialect("Create auto-ID insert query") - val dataParam = if (AutoId.needsAutoId(strategy, document, idField)) { - when (dialect) { - Dialect.POSTGRESQL -> - when (strategy) { - AutoId.NUMBER -> "' || (SELECT coalesce(max(data->>'$idField')::numeric, 0) + 1 " + - "FROM $tableName) || '" - AutoId.UUID -> "\"${AutoId.generateUUID()}\"" - AutoId.RANDOM_STRING -> "\"${AutoId.generateRandomString()}\"" - else -> "\"' || (:data)->>'$idField' || '\"" - }.let { ":data::jsonb || ('{\"$idField\":$it}')::jsonb" } - - Dialect.SQLITE -> - when (strategy) { - AutoId.NUMBER -> "(SELECT coalesce(max(data->>'$idField'), 0) + 1 FROM $tableName)" - AutoId.UUID -> "'${AutoId.generateUUID()}'" - AutoId.RANDOM_STRING -> "'${AutoId.generateRandomString()}'" - else -> "(:data)->>'$idField'" - }.let { "json_set(:data, '$.$idField', $it)" } - } - } else { - ":data" - } - - Document.insert(tableName).replace(":data", dataParam) + DocumentQuery.insert(tableName, strategy) } conn.customNonQuery(query, listOf(Parameters.json(":data", document))) } @@ -77,7 +51,7 @@ object Document { */ @JvmStatic fun save(tableName: String, document: TDoc, conn: Connection) = - conn.customNonQuery(Document.save(tableName), listOf(Parameters.json(":data", document))) + conn.customNonQuery(DocumentQuery.save(tableName), listOf(Parameters.json(":data", document))) /** * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert") @@ -100,7 +74,7 @@ object Document { @JvmStatic fun update(tableName: String, docId: TKey, document: TDoc, conn: Connection) = conn.customNonQuery( - statementWhere(Document.update(tableName), Where.byId(":id", docId)), + statementWhere(DocumentQuery.update(tableName), Where.byId(":id", docId)), Parameters.addFields( listOf(Field.equal(Configuration.idField, docId, ":id")), mutableListOf(Parameters.json(":data", document)) diff --git a/src/jvm/src/main/kotlin/jvm/Exists.kt b/src/jvm/src/main/kotlin/jvm/Exists.kt index d69fa88..96d3cfb 100644 --- a/src/jvm/src/main/kotlin/jvm/Exists.kt +++ b/src/jvm/src/main/kotlin/jvm/Exists.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.* import solutions.bitbadger.documents.extensions.customScalar -import solutions.bitbadger.documents.query.Exists +import solutions.bitbadger.documents.query.ExistsQuery import java.sql.Connection /** @@ -21,7 +21,7 @@ object Exists { @JvmStatic fun byId(tableName: String, docId: TKey, conn: Connection) = conn.customScalar( - Exists.byId(tableName, docId), + ExistsQuery.byId(tableName, docId), Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))), Boolean::class.java, Results::toExists @@ -57,7 +57,7 @@ object Exists { ): Boolean { val named = Parameters.nameFields(fields) return conn.customScalar( - Exists.byFields(tableName, named, howMatched), + ExistsQuery.byFields(tableName, named, howMatched), Parameters.addFields(named), Boolean::class.java, Results::toExists @@ -90,7 +90,7 @@ object Exists { @JvmStatic fun byContains(tableName: String, criteria: TContains, conn: Connection) = conn.customScalar( - Exists.byContains(tableName), + ExistsQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), Boolean::class.java, Results::toExists @@ -122,7 +122,7 @@ object Exists { @JvmStatic fun byJsonPath(tableName: String, path: String, conn: Connection) = conn.customScalar( - Exists.byJsonPath(tableName), + ExistsQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path)), Boolean::class.java, Results::toExists diff --git a/src/jvm/src/main/kotlin/jvm/Find.kt b/src/jvm/src/main/kotlin/jvm/Find.kt index ab22a91..59948cc 100644 --- a/src/jvm/src/main/kotlin/jvm/Find.kt +++ b/src/jvm/src/main/kotlin/jvm/Find.kt @@ -3,7 +3,7 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.* import solutions.bitbadger.documents.extensions.customList import solutions.bitbadger.documents.extensions.customSingle -import solutions.bitbadger.documents.query.Find +import solutions.bitbadger.documents.query.FindQuery import solutions.bitbadger.documents.query.orderBy import java.sql.Connection @@ -23,7 +23,7 @@ object Find { */ @JvmStatic fun all(tableName: String, clazz: Class, orderBy: Collection>? = null, conn: Connection) = - conn.customList(Find.all(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(), clazz, Results::fromData) + conn.customList(FindQuery.all(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(), clazz, Results::fromData) /** * Retrieve all documents in the given table @@ -62,7 +62,7 @@ object Find { @JvmStatic fun byId(tableName: String, docId: TKey, clazz: Class, conn: Connection) = conn.customSingle( - Find.byId(tableName, docId), + FindQuery.byId(tableName, docId), Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))), clazz, Results::fromData @@ -102,7 +102,7 @@ object Find { ): List { val named = Parameters.nameFields(fields) return conn.customList( - Find.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), Parameters.addFields(named), clazz, Results::fromData @@ -171,7 +171,7 @@ object Find { conn: Connection ) = conn.customList( - Find.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameters.json(":criteria", criteria)), clazz, Results::fromData @@ -234,7 +234,7 @@ object Find { conn: Connection ) = conn.customList( - Find.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameter(":path", ParameterType.STRING, path)), clazz, Results::fromData @@ -293,7 +293,7 @@ object Find { ): TDoc? { val named = Parameters.nameFields(fields) return conn.customSingle( - Find.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), Parameters.addFields(named), clazz, Results::fromData @@ -361,7 +361,7 @@ object Find { conn: Connection ) = conn.customSingle( - Find.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameters.json(":criteria", criteria)), clazz, Results::fromData @@ -429,7 +429,7 @@ object Find { conn: Connection ) = conn.customSingle( - Find.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameter(":path", ParameterType.STRING, path)), clazz, Results::fromData diff --git a/src/jvm/src/main/kotlin/jvm/Patch.kt b/src/jvm/src/main/kotlin/jvm/Patch.kt index 80d265a..1b09991 100644 --- a/src/jvm/src/main/kotlin/jvm/Patch.kt +++ b/src/jvm/src/main/kotlin/jvm/Patch.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.* import solutions.bitbadger.documents.extensions.customNonQuery -import solutions.bitbadger.documents.query.Patch +import solutions.bitbadger.documents.query.PatchQuery import java.sql.Connection /** @@ -21,7 +21,7 @@ object Patch { @JvmStatic fun byId(tableName: String, docId: TKey, patch: TPatch, conn: Connection) = conn.customNonQuery( - Patch.byId(tableName, docId), + PatchQuery.byId(tableName, docId), Parameters.addFields( listOf(Field.equal(Configuration.idField, docId, ":id")), mutableListOf(Parameters.json(":data", patch)) @@ -58,7 +58,7 @@ object Patch { ) { val named = Parameters.nameFields(fields) conn.customNonQuery( - Patch.byFields(tableName, named, howMatched), Parameters.addFields( + PatchQuery.byFields(tableName, named, howMatched), Parameters.addFields( named, mutableListOf(Parameters.json(":data", patch)) ) @@ -96,7 +96,7 @@ object Patch { @JvmStatic fun byContains(tableName: String, criteria: TContains, patch: TPatch, conn: Connection) = conn.customNonQuery( - Patch.byContains(tableName), + PatchQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria), Parameters.json(":data", patch)) ) @@ -126,7 +126,7 @@ object Patch { @JvmStatic fun byJsonPath(tableName: String, path: String, patch: TPatch, conn: Connection) = conn.customNonQuery( - Patch.byJsonPath(tableName), + PatchQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path), Parameters.json(":data", patch)) ) diff --git a/src/jvm/src/main/kotlin/jvm/RemoveFields.kt b/src/jvm/src/main/kotlin/jvm/RemoveFields.kt index 22bc308..0484b1e 100644 --- a/src/jvm/src/main/kotlin/jvm/RemoveFields.kt +++ b/src/jvm/src/main/kotlin/jvm/RemoveFields.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.jvm import solutions.bitbadger.documents.* import solutions.bitbadger.documents.extensions.customNonQuery -import solutions.bitbadger.documents.query.RemoveFields +import solutions.bitbadger.documents.query.RemoveFieldsQuery import java.sql.Connection /** @@ -36,7 +36,7 @@ object RemoveFields { fun byId(tableName: String, docId: TKey, toRemove: Collection, conn: Connection) { val nameParams = Parameters.fieldNames(toRemove) conn.customNonQuery( - RemoveFields.byId(tableName, nameParams, docId), + RemoveFieldsQuery.byId(tableName, nameParams, docId), Parameters.addFields( listOf(Field.equal(Configuration.idField, docId, ":id")), translatePath(nameParams) @@ -75,7 +75,7 @@ object RemoveFields { val named = Parameters.nameFields(fields) val nameParams = Parameters.fieldNames(toRemove) conn.customNonQuery( - RemoveFields.byFields(tableName, nameParams, named, howMatched), + RemoveFieldsQuery.byFields(tableName, nameParams, named, howMatched), Parameters.addFields(named, translatePath(nameParams)) ) } @@ -117,7 +117,7 @@ object RemoveFields { ) { val nameParams = Parameters.fieldNames(toRemove) conn.customNonQuery( - RemoveFields.byContains(tableName, nameParams), + RemoveFieldsQuery.byContains(tableName, nameParams), listOf(Parameters.json(":criteria", criteria), *nameParams.toTypedArray()) ) } @@ -149,7 +149,7 @@ object RemoveFields { fun byJsonPath(tableName: String, path: String, toRemove: Collection, conn: Connection) { val nameParams = Parameters.fieldNames(toRemove) conn.customNonQuery( - RemoveFields.byJsonPath(tableName, nameParams), + RemoveFieldsQuery.byJsonPath(tableName, nameParams), listOf(Parameter(":path", ParameterType.STRING, path), *nameParams.toTypedArray()) ) } diff --git a/src/jvm/src/main/kotlin/query/Count.kt b/src/jvm/src/main/kotlin/query/CountQuery.kt similarity index 80% rename from src/jvm/src/main/kotlin/query/Count.kt rename to src/jvm/src/main/kotlin/query/CountQuery.kt index e3db117..82b97b4 100644 --- a/src/jvm/src/main/kotlin/query/Count.kt +++ b/src/jvm/src/main/kotlin/query/CountQuery.kt @@ -1,13 +1,15 @@ package solutions.bitbadger.documents.query +import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.FieldMatch -import solutions.bitbadger.documents.query.byFields as byFieldsBase; +import kotlin.jvm.Throws +import solutions.bitbadger.documents.query.byFields as byFieldsBase /** * Functions to count documents */ -object Count { +object CountQuery { /** * Query to count all documents in a table @@ -15,6 +17,7 @@ object Count { * @param tableName The table in which to count documents (may include schema) * @return A query to count documents */ + @JvmStatic fun all(tableName: String) = "SELECT COUNT(*) AS it FROM $tableName" @@ -26,6 +29,8 @@ object Count { * @param howMatched How fields should be compared (optional, defaults to ALL) * @return A query to count documents matching the given fields */ + @JvmStatic + @JvmOverloads fun byFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = byFieldsBase(all(tableName), fields, howMatched) @@ -34,7 +39,10 @@ object Count { * * @param tableName The table in which to count documents (may include schema) * @return A query to count documents via JSON containment + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byContains(tableName: String) = statementWhere(all(tableName), Where.jsonContains()) @@ -43,7 +51,10 @@ object Count { * * @param tableName The table in which to count documents (may include schema) * @return A query to count documents via a JSON path match + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byJsonPath(tableName: String) = statementWhere(all(tableName), Where.jsonPathMatches()) } diff --git a/src/jvm/src/main/kotlin/query/Definition.kt b/src/jvm/src/main/kotlin/query/DefinitionQuery.kt similarity index 87% rename from src/jvm/src/main/kotlin/query/Definition.kt rename to src/jvm/src/main/kotlin/query/DefinitionQuery.kt index 6187216..24876bb 100644 --- a/src/jvm/src/main/kotlin/query/Definition.kt +++ b/src/jvm/src/main/kotlin/query/DefinitionQuery.kt @@ -1,11 +1,12 @@ package solutions.bitbadger.documents.query import solutions.bitbadger.documents.* +import kotlin.jvm.Throws /** * Functions to create queries to define tables and indexes */ -object Definition { +object DefinitionQuery { /** * SQL statement to create a document table @@ -14,6 +15,7 @@ object Definition { * @param dataType The type of data for the column (`JSON`, `JSONB`, etc.) * @return A query to create a document table */ + @JvmStatic fun ensureTableFor(tableName: String, dataType: String) = "CREATE TABLE IF NOT EXISTS $tableName (data $dataType NOT NULL)" @@ -23,7 +25,11 @@ object Definition { * @param tableName The name of the table to create (may include schema) * @param dialect The dialect to generate (optional, used in place of current) * @return A query to create a document table + * @throws DocumentException If the dialect is neither provided nor configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun ensureTable(tableName: String, dialect: Dialect? = null) = when (dialect ?: Configuration.dialect("create table creation query")) { Dialect.POSTGRESQL -> ensureTableFor(tableName, "JSONB") @@ -47,7 +53,11 @@ object Definition { * @param fields One or more fields to include in the index * @param dialect The SQL dialect to use when creating this index (optional, used in place of current) * @return A query to create the field index + * @throws DocumentException If the dialect is neither provided nor configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun ensureIndexOn( tableName: String, indexName: String, @@ -70,7 +80,11 @@ object Definition { * @param tableName The table on which a key index should be created (may include schema) * @param dialect The SQL dialect to use when creating this index (optional, used in place of current) * @return A query to create the key index + * @throws DocumentException If the dialect is neither provided nor configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun ensureKey(tableName: String, dialect: Dialect? = null) = ensureIndexOn(tableName, "key", listOf(Configuration.idField), dialect).replace("INDEX", "UNIQUE INDEX") @@ -82,6 +96,8 @@ object Definition { * @return The SQL statement to create an index on JSON documents in the specified table * @throws DocumentException If the database mode is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun ensureDocumentIndexOn(tableName: String, indexType: DocumentIndex): String { if (Configuration.dialect("create document index query") != Dialect.POSTGRESQL) { throw DocumentException("'Document indexes are only supported on PostgreSQL") diff --git a/src/jvm/src/main/kotlin/query/Delete.kt b/src/jvm/src/main/kotlin/query/DeleteQuery.kt similarity index 84% rename from src/jvm/src/main/kotlin/query/Delete.kt rename to src/jvm/src/main/kotlin/query/DeleteQuery.kt index 0899c8b..8241a6e 100644 --- a/src/jvm/src/main/kotlin/query/Delete.kt +++ b/src/jvm/src/main/kotlin/query/DeleteQuery.kt @@ -1,14 +1,16 @@ package solutions.bitbadger.documents.query +import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.FieldMatch +import kotlin.jvm.Throws import solutions.bitbadger.documents.query.byFields as byFieldsBase import solutions.bitbadger.documents.query.byId as byIdBase /** * Functions to delete documents */ -object Delete { +object DeleteQuery { /** * Query to delete documents from a table @@ -26,6 +28,8 @@ object Delete { * @param docId The ID of the document (optional, used for type checking) * @return A query to delete a document by its ID */ + @JvmStatic + @JvmOverloads fun byId(tableName: String, docId: TKey? = null) = byIdBase(delete(tableName), docId) @@ -37,6 +41,8 @@ object Delete { * @param howMatched How fields should be compared (optional, defaults to ALL) * @return A query to delete documents matching for the given fields */ + @JvmStatic + @JvmOverloads fun byFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = byFieldsBase(delete(tableName), fields, howMatched) @@ -45,7 +51,10 @@ object Delete { * * @param tableName The table from which documents should be deleted (may include schema) * @return A query to delete documents via JSON containment + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byContains(tableName: String) = statementWhere(delete(tableName), Where.jsonContains()) @@ -54,7 +63,10 @@ object Delete { * * @param tableName The table from which documents should be deleted (may include schema) * @return A query to delete documents via a JSON path match + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byJsonPath(tableName: String) = statementWhere(delete(tableName), Where.jsonPathMatches()) } diff --git a/src/jvm/src/main/kotlin/query/Document.kt b/src/jvm/src/main/kotlin/query/DocumentQuery.kt similarity index 85% rename from src/jvm/src/main/kotlin/query/Document.kt rename to src/jvm/src/main/kotlin/query/DocumentQuery.kt index c60c986..34834c6 100644 --- a/src/jvm/src/main/kotlin/query/Document.kt +++ b/src/jvm/src/main/kotlin/query/DocumentQuery.kt @@ -3,20 +3,26 @@ package solutions.bitbadger.documents.query import solutions.bitbadger.documents.AutoId import solutions.bitbadger.documents.Configuration import solutions.bitbadger.documents.Dialect +import solutions.bitbadger.documents.DocumentException +import kotlin.jvm.Throws /** * Functions for document-level operations */ -object Document { +object DocumentQuery { /** * Query to insert a document * * @param tableName The table into which to insert (may include schema) * @return A query to insert a document + * @throws DocumentException If the dialect is not configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun insert(tableName: String, autoId: AutoId? = null): String { - val id = Configuration.idField + val id = Configuration.idField val values = when (Configuration.dialect("create INSERT statement")) { Dialect.POSTGRESQL -> when (autoId ?: AutoId.DISABLED) { AutoId.DISABLED -> ":data" @@ -42,7 +48,10 @@ object Document { * * @param tableName The table into which to save (may include schema) * @return A query to save a document + * @throws DocumentException If the dialect is not configured */ + @Throws(DocumentException::class) + @JvmStatic fun save(tableName: String) = insert(tableName, AutoId.DISABLED) + " ON CONFLICT ((data->>'${Configuration.idField}')) DO UPDATE SET data = EXCLUDED.data" @@ -53,6 +62,7 @@ object Document { * @param tableName The table in which documents should be replaced (may include schema) * @return A query to update documents */ + @JvmStatic fun update(tableName: String) = "UPDATE $tableName SET data = :data" } diff --git a/src/jvm/src/main/kotlin/query/Exists.kt b/src/jvm/src/main/kotlin/query/ExistsQuery.kt similarity index 84% rename from src/jvm/src/main/kotlin/query/Exists.kt rename to src/jvm/src/main/kotlin/query/ExistsQuery.kt index 54689d0..a77457e 100644 --- a/src/jvm/src/main/kotlin/query/Exists.kt +++ b/src/jvm/src/main/kotlin/query/ExistsQuery.kt @@ -1,12 +1,14 @@ package solutions.bitbadger.documents.query +import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.FieldMatch +import kotlin.jvm.Throws /** * Functions to check for document existence */ -object Exists { +object ExistsQuery { /** * Query to check for document existence in a table @@ -25,6 +27,8 @@ object Exists { * @param docId The ID of the document (optional, used for type checking) * @return A query to determine document existence by ID */ + @JvmStatic + @JvmOverloads fun byId(tableName: String, docId: TKey? = null) = exists(tableName, Where.byId(docId = docId)) @@ -36,6 +40,8 @@ object Exists { * @param howMatched How fields should be compared (optional, defaults to ALL) * @return A query to determine document existence for the given fields */ + @JvmStatic + @JvmOverloads fun byFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = exists(tableName, Where.byFields(fields, howMatched)) @@ -44,7 +50,10 @@ object Exists { * * @param tableName The table in which existence should be checked (may include schema) * @return A query to determine document existence via JSON containment + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byContains(tableName: String) = exists(tableName, Where.jsonContains()) @@ -53,7 +62,10 @@ object Exists { * * @param tableName The table in which existence should be checked (may include schema) * @return A query to determine document existence via a JSON path match + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byJsonPath(tableName: String) = exists(tableName, Where.jsonPathMatches()) } diff --git a/src/jvm/src/main/kotlin/query/Find.kt b/src/jvm/src/main/kotlin/query/FindQuery.kt similarity index 84% rename from src/jvm/src/main/kotlin/query/Find.kt rename to src/jvm/src/main/kotlin/query/FindQuery.kt index 6d57232..3606a2b 100644 --- a/src/jvm/src/main/kotlin/query/Find.kt +++ b/src/jvm/src/main/kotlin/query/FindQuery.kt @@ -1,14 +1,16 @@ package solutions.bitbadger.documents.query +import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.FieldMatch +import kotlin.jvm.Throws import solutions.bitbadger.documents.query.byId as byIdBase import solutions.bitbadger.documents.query.byFields as byFieldsBase /** * Functions to retrieve documents */ -object Find { +object FindQuery { /** * Query to retrieve all documents from a table @@ -16,6 +18,7 @@ object Find { * @param tableName The table from which documents should be retrieved (may include schema) * @return A query to retrieve documents */ + @JvmStatic fun all(tableName: String) = "SELECT data FROM $tableName" @@ -26,6 +29,8 @@ object Find { * @param docId The ID of the document (optional, used for type checking) * @return A query to retrieve a document by its ID */ + @JvmStatic + @JvmOverloads fun byId(tableName: String, docId: TKey? = null) = byIdBase(all(tableName), docId) @@ -37,6 +42,8 @@ object Find { * @param howMatched How fields should be compared (optional, defaults to ALL) * @return A query to retrieve documents matching the given fields */ + @JvmStatic + @JvmOverloads fun byFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = byFieldsBase(all(tableName), fields, howMatched) @@ -45,7 +52,10 @@ object Find { * * @param tableName The table from which documents should be retrieved (may include schema) * @return A query to retrieve documents via JSON containment + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byContains(tableName: String) = statementWhere(all(tableName), Where.jsonContains()) @@ -54,7 +64,10 @@ object Find { * * @param tableName The table from which documents should be retrieved (may include schema) * @return A query to retrieve documents via a JSON path match + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byJsonPath(tableName: String) = statementWhere(all(tableName), Where.jsonPathMatches()) } diff --git a/src/jvm/src/main/kotlin/query/Patch.kt b/src/jvm/src/main/kotlin/query/PatchQuery.kt similarity index 79% rename from src/jvm/src/main/kotlin/query/Patch.kt rename to src/jvm/src/main/kotlin/query/PatchQuery.kt index dc1e699..dbde8fe 100644 --- a/src/jvm/src/main/kotlin/query/Patch.kt +++ b/src/jvm/src/main/kotlin/query/PatchQuery.kt @@ -1,16 +1,14 @@ package solutions.bitbadger.documents.query -import solutions.bitbadger.documents.Configuration -import solutions.bitbadger.documents.Dialect -import solutions.bitbadger.documents.Field -import solutions.bitbadger.documents.FieldMatch +import solutions.bitbadger.documents.* +import kotlin.jvm.Throws import solutions.bitbadger.documents.query.byFields as byFieldsBase import solutions.bitbadger.documents.query.byId as byIdBase /** * Functions to create queries to patch (partially update) JSON documents */ -object Patch { +object PatchQuery { /** * Create an `UPDATE` statement to patch documents @@ -30,7 +28,11 @@ object Patch { * @param tableName The name of the table where the document is stored * @param docId The ID of the document to be updated (optional, used for type checking) * @return A query to patch a JSON document by its ID + * @throws DocumentException If the dialect is not configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun byId(tableName: String, docId: TKey? = null) = byIdBase(patch(tableName), docId) @@ -41,7 +43,11 @@ object Patch { * @param fields The field criteria * @param howMatched How the fields should be matched (optional, defaults to `ALL`) * @return A query to patch JSON documents by field match criteria + * @throws DocumentException If the dialect is not configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun byFields(tableName: String, fields: Collection>, howMatched: FieldMatch? = null) = byFieldsBase(patch(tableName), fields, howMatched) @@ -50,7 +56,10 @@ object Patch { * * @param tableName The name of the table where the document is stored * @return A query to patch JSON documents by JSON containment + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byContains(tableName: String) = statementWhere(patch(tableName), Where.jsonContains()) @@ -59,7 +68,10 @@ object Patch { * * @param tableName The name of the table where the document is stored * @return A query to patch JSON documents by JSON path match + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byJsonPath(tableName: String) = statementWhere(patch(tableName), Where.jsonPathMatches()) } diff --git a/src/jvm/src/main/kotlin/query/Query.kt b/src/jvm/src/main/kotlin/query/Query.kt index 39784bc..c79203e 100644 --- a/src/jvm/src/main/kotlin/query/Query.kt +++ b/src/jvm/src/main/kotlin/query/Query.kt @@ -1,3 +1,4 @@ +@file:JvmName("QueryUtils") package solutions.bitbadger.documents.query import solutions.bitbadger.documents.Configuration @@ -35,6 +36,7 @@ fun byId(statement: String, docId: TKey) = * @param howMatched Whether to match any or all of the field conditions (optional; default ALL) * @return A query addressing documents by field matching conditions */ +@JvmOverloads fun byFields(statement: String, fields: Collection>, howMatched: FieldMatch? = null) = statementWhere(statement, Where.byFields(fields, howMatched)) @@ -45,6 +47,7 @@ fun byFields(statement: String, fields: Collection>, howMatched: FieldM * @param dialect The SQL dialect for the generated clause * @return An `ORDER BY` clause for the given fields */ +@JvmOverloads fun orderBy(fields: Collection>, dialect: Dialect? = null): String { val mode = dialect ?: Configuration.dialect("generate ORDER BY clause") if (fields.isEmpty()) return "" diff --git a/src/jvm/src/main/kotlin/query/RemoveFields.kt b/src/jvm/src/main/kotlin/query/RemoveFieldsQuery.kt similarity index 84% rename from src/jvm/src/main/kotlin/query/RemoveFields.kt rename to src/jvm/src/main/kotlin/query/RemoveFieldsQuery.kt index b3842c4..fd036ee 100644 --- a/src/jvm/src/main/kotlin/query/RemoveFields.kt +++ b/src/jvm/src/main/kotlin/query/RemoveFieldsQuery.kt @@ -1,13 +1,14 @@ package solutions.bitbadger.documents.query import solutions.bitbadger.documents.* +import kotlin.jvm.Throws import solutions.bitbadger.documents.query.byFields as byFieldsBase import solutions.bitbadger.documents.query.byId as byIdBase /** * Functions to create queries to remove fields from documents */ -object RemoveFields { +object RemoveFieldsQuery { /** * Create a query to remove fields based on the given parameters @@ -31,7 +32,11 @@ object RemoveFields { * @param toRemove The parameters for the fields to be removed * @param docId The ID of the document to be updated (optional, used for type checking) * @return A query to patch a JSON document by its ID + * @throws DocumentException If the dialect is not configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun byId(tableName: String, toRemove: Collection>, docId: TKey? = null) = byIdBase(removeFields(tableName, toRemove), docId) @@ -43,7 +48,11 @@ object RemoveFields { * @param fields The field criteria * @param howMatched How the fields should be matched (optional, defaults to `ALL`) * @return A query to patch JSON documents by field match criteria + * @throws DocumentException If the dialect is not configured */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun byFields( tableName: String, toRemove: Collection>, @@ -58,7 +67,10 @@ object RemoveFields { * @param tableName The name of the table where the document is stored * @param toRemove The parameters for the fields to be removed * @return A query to patch JSON documents by JSON containment + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byContains(tableName: String, toRemove: Collection>) = statementWhere(removeFields(tableName, toRemove), Where.jsonContains()) @@ -68,7 +80,10 @@ object RemoveFields { * @param tableName The name of the table where the document is stored * @param toRemove The parameters for the fields to be removed * @return A query to patch JSON documents by JSON path match + * @throws DocumentException If the database dialect is not PostgreSQL */ + @Throws(DocumentException::class) + @JvmStatic fun byJsonPath(tableName: String, toRemove: Collection>) = statementWhere(removeFields(tableName, toRemove), Where.jsonPathMatches()) } diff --git a/src/jvm/src/main/kotlin/query/Where.kt b/src/jvm/src/main/kotlin/query/Where.kt index dce4a32..626002e 100644 --- a/src/jvm/src/main/kotlin/query/Where.kt +++ b/src/jvm/src/main/kotlin/query/Where.kt @@ -5,6 +5,7 @@ import solutions.bitbadger.documents.Dialect import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.FieldMatch +import kotlin.jvm.Throws /** * Functions to create `WHERE` clause fragments @@ -18,6 +19,8 @@ object Where { * @param howMatched How the fields should be matched (optional, defaults to `ALL`) * @return A `WHERE` clause fragment to match the given fields */ + @JvmStatic + @JvmOverloads fun byFields(fields: Collection>, howMatched: FieldMatch? = null) = fields.joinToString(" ${(howMatched ?: FieldMatch.ALL).sql} ") { it.toWhere() } @@ -27,6 +30,8 @@ object Where { * @param parameterName The parameter name to use for the ID placeholder (optional, defaults to ":id") * @param docId The ID value (optional; used for type determinations, string assumed if not provided) */ + @JvmStatic + @JvmOverloads fun byId(parameterName: String = ":id", docId: TKey? = null) = byFields(listOf(Field.equal(Configuration.idField, docId ?: "", parameterName))) @@ -37,6 +42,9 @@ object Where { * @return A `WHERE` clause fragment to implement a JSON containment criterion * @throws DocumentException If called against a SQLite database */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun jsonContains(parameterName: String = ":criteria") = when (Configuration.dialect("create containment WHERE clause")) { Dialect.POSTGRESQL -> "data @> $parameterName" @@ -50,6 +58,9 @@ object Where { * @return A `WHERE` clause fragment to implement a JSON path match criterion * @throws DocumentException If called against a SQLite database */ + @Throws(DocumentException::class) + @JvmStatic + @JvmOverloads fun jsonPathMatches(parameterName: String = ":path") = when (Configuration.dialect("create JSON path match WHERE clause")) { Dialect.POSTGRESQL -> "jsonb_path_exists(data, $parameterName::jsonpath)" diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/AutoIdTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/AutoIdTest.java index 511d621..b157359 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/AutoIdTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/AutoIdTest.java @@ -11,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.*; /** * Unit tests for the `AutoId` enum */ -@DisplayName("Java | Common | AutoId") +@DisplayName("JVM | Java | AutoId") final public class AutoIdTest { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/DocumentIndexTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/DocumentIndexTest.java index 47b9543..72b3d79 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/DocumentIndexTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/DocumentIndexTest.java @@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; /** * Unit tests for the `DocumentIndex` enum */ -@DisplayName("Java | Common | DocumentIndex") +@DisplayName("JVM | Java | DocumentIndex") final public class DocumentIndexTest { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldMatchTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldMatchTest.java index 6854747..f9dab5f 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldMatchTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldMatchTest.java @@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; /** * Unit tests for the `FieldMatch` enum */ -@DisplayName("Java | Common | FieldMatch") +@DisplayName("JVM | Java | FieldMatch") final public class FieldMatchTest { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldTest.java index 9af8b6d..2a7572d 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/FieldTest.java @@ -14,7 +14,7 @@ import static org.junit.jupiter.api.Assertions.*; /** * Unit tests for the `Field` class */ -@DisplayName("Java | Common | Field") +@DisplayName("JVM | Java | Field") final public class FieldTest { /** diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/OpTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/OpTest.java index 3f800c8..f216ee4 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/OpTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/OpTest.java @@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; /** * Unit tests for the `Op` enum */ -@DisplayName("Java | Common | Op") +@DisplayName("JVM | Java | Op") final public class OpTest { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterNameTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterNameTest.java index 4a38121..1c18044 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterNameTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterNameTest.java @@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; /** * Unit tests for the `ParameterName` class */ -@DisplayName("Java | Common | ParameterName") +@DisplayName("JVM | Java | ParameterName") final public class ParameterNameTest { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterTest.java index acbf0cf..9ca4432 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/ParameterTest.java @@ -11,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.*; /** * Unit tests for the `Parameter` class */ -@DisplayName("Java | Common | Parameter") +@DisplayName("JVM | Java | Parameter") final public class ParameterTest { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/ParametersTest.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/ParametersTest.java index 59902e7..4c5f39f 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/ParametersTest.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/ParametersTest.java @@ -13,7 +13,7 @@ import static org.junit.jupiter.api.Assertions.*; /** * Unit tests for the `Parameters` object */ -@DisplayName("Java | Java | Parameters") +@DisplayName("JVM | Java | Parameters") final public class ParametersTest { /** diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/common/CountFunctions.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/common/CountFunctions.java index f3dfd47..c32598d 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/common/CountFunctions.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/common/CountFunctions.java @@ -1,14 +1,15 @@ package solutions.bitbadger.documents.java.jvm.integration.common; +import solutions.bitbadger.documents.DocumentException; import solutions.bitbadger.documents.Field; -import solutions.bitbadger.documents.jvm.Count; -import solutions.bitbadger.documents.support.ThrowawayDatabase; import solutions.bitbadger.documents.java.support.JsonDocument; +import solutions.bitbadger.documents.support.ThrowawayDatabase; import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.assertEquals; +import static solutions.bitbadger.documents.extensions.ConnExt.*; import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE; /** @@ -18,42 +19,42 @@ final public class CountFunctions { public static void all(ThrowawayDatabase db) { JsonDocument.load(db); - assertEquals(5L, Count.all(TEST_TABLE, db.getConn()), "There should have been 5 documents in the table"); + assertEquals(5L, countAll(db.getConn(), TEST_TABLE), "There should have been 5 documents in the table"); } public static void byFieldsNumeric(ThrowawayDatabase db) { JsonDocument.load(db); - assertEquals(3L, Count.byFields(TEST_TABLE, List.of(Field.between("numValue", 10, 20)), db.getConn()), + assertEquals(3L, countByFields(db.getConn(), TEST_TABLE, List.of(Field.between("numValue", 10, 20))), "There should have been 3 matching documents"); } public static void byFieldsAlpha(ThrowawayDatabase db) { JsonDocument.load(db); - assertEquals(1L, Count.byFields(TEST_TABLE, List.of(Field.between("value", "aardvark", "apple")), db.getConn()), + assertEquals(1L, countByFields(db.getConn(), TEST_TABLE, List.of(Field.between("value", "aardvark", "apple"))), "There should have been 1 matching document"); } - public static void byContainsMatch(ThrowawayDatabase db) { + public static void byContainsMatch(ThrowawayDatabase db) throws DocumentException { JsonDocument.load(db); - assertEquals(2L, Count.byContains(TEST_TABLE, Map.of("value", "purple"), db.getConn()), + assertEquals(2L, countByContains(db.getConn(), TEST_TABLE, Map.of("value", "purple")), "There should have been 2 matching documents"); } - public static void byContainsNoMatch(ThrowawayDatabase db) { + public static void byContainsNoMatch(ThrowawayDatabase db) throws DocumentException { JsonDocument.load(db); - assertEquals(0L, Count.byContains(TEST_TABLE, Map.of("value", "magenta"), db.getConn()), + assertEquals(0L, countByContains(db.getConn(), TEST_TABLE, Map.of("value", "magenta")), "There should have been no matching documents"); } - public static void byJsonPathMatch(ThrowawayDatabase db) { + public static void byJsonPathMatch(ThrowawayDatabase db) throws DocumentException { JsonDocument.load(db); - assertEquals(2L, Count.byJsonPath(TEST_TABLE, "$.numValue ? (@ < 5)", db.getConn()), + assertEquals(2L, countByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ < 5)"), "There should have been 2 matching documents"); } - public static void byJsonPathNoMatch(ThrowawayDatabase db) { + public static void byJsonPathNoMatch(ThrowawayDatabase db) throws DocumentException { JsonDocument.load(db); - assertEquals(0L, Count.byJsonPath(TEST_TABLE, "$.numValue ? (@ > 100)", db.getConn()), + assertEquals(0L, countByJsonPath(db.getConn(), TEST_TABLE, "$.numValue ? (@ > 100)"), "There should have been no matching documents"); } diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/postgresql/CountIT.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/postgresql/CountIT.java index eb07bec..97c1d3f 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/postgresql/CountIT.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/postgresql/CountIT.java @@ -2,13 +2,14 @@ package solutions.bitbadger.documents.java.jvm.integration.postgresql; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import solutions.bitbadger.documents.DocumentException; import solutions.bitbadger.documents.java.jvm.integration.common.CountFunctions; import solutions.bitbadger.documents.jvm.integration.postgresql.PgDB; /** * PostgreSQL integration tests for the `Count` object / `count*` connection extension functions */ -@DisplayName("Java | Java | PostgreSQL: Count") +@DisplayName("JVM | Java | PostgreSQL: Count") public class CountIT { @Test @@ -37,7 +38,7 @@ public class CountIT { @Test @DisplayName("byContains counts documents when matches are found") - public void byContainsMatch() { + public void byContainsMatch() throws DocumentException { try (PgDB db = new PgDB()) { CountFunctions.byContainsMatch(db); } @@ -45,7 +46,7 @@ public class CountIT { @Test @DisplayName("byContains counts documents when no matches are found") - public void byContainsNoMatch() { + public void byContainsNoMatch() throws DocumentException { try (PgDB db = new PgDB()) { CountFunctions.byContainsNoMatch(db); } @@ -53,7 +54,7 @@ public class CountIT { @Test @DisplayName("byJsonPath counts documents when matches are found") - public void byJsonPathMatch() { + public void byJsonPathMatch() throws DocumentException { try (PgDB db = new PgDB()) { CountFunctions.byJsonPathMatch(db); } @@ -61,7 +62,7 @@ public class CountIT { @Test @DisplayName("byJsonPath counts documents when no matches are found") - public void byJsonPathNoMatch() { + public void byJsonPathNoMatch() throws DocumentException { try (PgDB db = new PgDB()) { CountFunctions.byJsonPathNoMatch(db); } diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/sqlite/CountIT.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/sqlite/CountIT.java index 18a4d70..38fda0b 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/sqlite/CountIT.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/jvm/integration/sqlite/CountIT.java @@ -11,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows; /** * SQLite integration tests for the `Count` object / `count*` connection extension functions */ -@DisplayName("Java | Java | SQLite: Count") +@DisplayName("JVM | Java | SQLite: Count") public class CountIT { @Test diff --git a/src/jvm/src/test/java/solutions/bitbadger/documents/java/support/JsonDocument.java b/src/jvm/src/test/java/solutions/bitbadger/documents/java/support/JsonDocument.java index d18acaa..4d5b085 100644 --- a/src/jvm/src/test/java/solutions/bitbadger/documents/java/support/JsonDocument.java +++ b/src/jvm/src/test/java/solutions/bitbadger/documents/java/support/JsonDocument.java @@ -1,6 +1,5 @@ package solutions.bitbadger.documents.java.support; -import kotlinx.serialization.Serializable; import solutions.bitbadger.documents.jvm.Document; import solutions.bitbadger.documents.support.ThrowawayDatabase; @@ -8,7 +7,6 @@ import java.util.List; import static solutions.bitbadger.documents.support.TypesKt.TEST_TABLE; -@Serializable public class JsonDocument { private String id; diff --git a/src/jvm/src/test/kotlin/AutoIdTest.kt b/src/jvm/src/test/kotlin/AutoIdTest.kt index 4a1aeff..87099ae 100644 --- a/src/jvm/src/test/kotlin/AutoIdTest.kt +++ b/src/jvm/src/test/kotlin/AutoIdTest.kt @@ -3,6 +3,7 @@ package solutions.bitbadger.documents import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows +import solutions.bitbadger.documents.support.* import kotlin.test.assertEquals import kotlin.test.assertFalse import kotlin.test.assertNotEquals @@ -11,7 +12,7 @@ import kotlin.test.assertTrue /** * Unit tests for the `AutoId` enum */ -@DisplayName("Kotlin | Common | AutoId") +@DisplayName("JVM | Kotlin | AutoId") class AutoIdTest { @Test @@ -157,9 +158,3 @@ class AutoIdTest { assertThrows { AutoId.needsAutoId(AutoId.RANDOM_STRING, ShortIdClass(55), "id") } } } - -data class ByteIdClass(val id: Byte) -data class ShortIdClass(val id: Short) -data class IntIdClass(val id: Int) -data class LongIdClass(val id: Long) -data class StringIdClass(val id: String) diff --git a/src/jvm/src/test/kotlin/ComparisonTest.kt b/src/jvm/src/test/kotlin/ComparisonTest.kt index 912000b..46c3cae 100644 --- a/src/jvm/src/test/kotlin/ComparisonTest.kt +++ b/src/jvm/src/test/kotlin/ComparisonTest.kt @@ -9,7 +9,7 @@ import kotlin.test.assertTrue /** * Unit tests for the `ComparisonBetween` class */ -@DisplayName("ComparisonBetween") +@DisplayName("JVM | Kotlin | ComparisonBetween") class ComparisonBetweenTest { @Test @@ -50,7 +50,7 @@ class ComparisonBetweenTest { /** * Unit tests for the `ComparisonIn` class */ -@DisplayName("ComparisonIn") +@DisplayName("JVM | Kotlin | ComparisonIn") class ComparisonInTest { @Test @@ -92,7 +92,7 @@ class ComparisonInTest { /** * Unit tests for the `ComparisonInArray` class */ -@DisplayName("ComparisonInArray") +@DisplayName("JVM | Kotlin | ComparisonInArray") class ComparisonInArrayTest { @Test @@ -138,7 +138,7 @@ class ComparisonInArrayTest { /** * Unit tests for the `ComparisonSingle` class */ -@DisplayName("ComparisonSingle") +@DisplayName("JVM | Kotlin | ComparisonSingle") class ComparisonSingleTest { @Test diff --git a/src/jvm/src/test/kotlin/ConfigurationTest.kt b/src/jvm/src/test/kotlin/ConfigurationTest.kt index a9255a5..bdc8e97 100644 --- a/src/jvm/src/test/kotlin/ConfigurationTest.kt +++ b/src/jvm/src/test/kotlin/ConfigurationTest.kt @@ -8,7 +8,7 @@ import kotlin.test.assertEquals /** * Unit tests for the `Configuration` object */ -@DisplayName("Kotlin | Common | Configuration") +@DisplayName("JVM | Kotlin | Configuration") class ConfigurationTest { @Test diff --git a/src/jvm/src/test/kotlin/DialectTest.kt b/src/jvm/src/test/kotlin/DialectTest.kt index 7dbdce0..f6b4025 100644 --- a/src/jvm/src/test/kotlin/DialectTest.kt +++ b/src/jvm/src/test/kotlin/DialectTest.kt @@ -9,7 +9,7 @@ import kotlin.test.assertTrue /** * Unit tests for the `Dialect` enum */ -@DisplayName("Kotlin | Common | Dialect") +@DisplayName("JVM | Kotlin | Dialect") class DialectTest { @Test diff --git a/src/jvm/src/test/kotlin/DocumentIndexTest.kt b/src/jvm/src/test/kotlin/DocumentIndexTest.kt index f23d6a0..fccbb44 100644 --- a/src/jvm/src/test/kotlin/DocumentIndexTest.kt +++ b/src/jvm/src/test/kotlin/DocumentIndexTest.kt @@ -7,7 +7,7 @@ import kotlin.test.assertEquals /** * Unit tests for the `DocumentIndex` enum */ -@DisplayName("Kotlin | Common | DocumentIndex") +@DisplayName("JVM | Kotlin | DocumentIndex") class DocumentIndexTest { @Test diff --git a/src/jvm/src/test/kotlin/FieldMatchTest.kt b/src/jvm/src/test/kotlin/FieldMatchTest.kt index 2ee51d7..3976773 100644 --- a/src/jvm/src/test/kotlin/FieldMatchTest.kt +++ b/src/jvm/src/test/kotlin/FieldMatchTest.kt @@ -7,7 +7,7 @@ import kotlin.test.assertEquals /** * Unit tests for the `FieldMatch` enum */ -@DisplayName("Kotlin | Common | FieldMatch") +@DisplayName("JVM | Kotlin | FieldMatch") class FieldMatchTest { @Test diff --git a/src/jvm/src/test/kotlin/FieldTest.kt b/src/jvm/src/test/kotlin/FieldTest.kt index a48dbf1..12b71e5 100644 --- a/src/jvm/src/test/kotlin/FieldTest.kt +++ b/src/jvm/src/test/kotlin/FieldTest.kt @@ -11,7 +11,7 @@ import kotlin.test.assertNull /** * Unit tests for the `Field` class */ -@DisplayName("Kotlin | Common | Field") +@DisplayName("JVM | Kotlin | Field") class FieldTest { /** diff --git a/src/jvm/src/test/kotlin/OpTest.kt b/src/jvm/src/test/kotlin/OpTest.kt index 095e9a2..19e0d91 100644 --- a/src/jvm/src/test/kotlin/OpTest.kt +++ b/src/jvm/src/test/kotlin/OpTest.kt @@ -7,7 +7,7 @@ import kotlin.test.assertEquals /** * Unit tests for the `Op` enum */ -@DisplayName("Kotlin | Common | Op") +@DisplayName("JVM | Kotlin | Op") class OpTest { @Test diff --git a/src/jvm/src/test/kotlin/ParameterNameTest.kt b/src/jvm/src/test/kotlin/ParameterNameTest.kt index d8f1d6d..4e67e4a 100644 --- a/src/jvm/src/test/kotlin/ParameterNameTest.kt +++ b/src/jvm/src/test/kotlin/ParameterNameTest.kt @@ -7,7 +7,7 @@ import kotlin.test.assertEquals /** * Unit tests for the `ParameterName` class */ -@DisplayName("Kotlin | Common | ParameterName") +@DisplayName("JVM | Kotlin | ParameterName") class ParameterNameTest { @Test diff --git a/src/jvm/src/test/kotlin/ParameterTest.kt b/src/jvm/src/test/kotlin/ParameterTest.kt index 0dadc04..0ec84ae 100644 --- a/src/jvm/src/test/kotlin/ParameterTest.kt +++ b/src/jvm/src/test/kotlin/ParameterTest.kt @@ -9,7 +9,7 @@ import kotlin.test.assertNull /** * Unit tests for the `Parameter` class */ -@DisplayName("Kotlin | Common | Parameter") +@DisplayName("JVM | Kotlin | Parameter") class ParameterTest { @Test diff --git a/src/jvm/src/test/kotlin/jvm/ParametersTest.kt b/src/jvm/src/test/kotlin/jvm/ParametersTest.kt index 30ef568..ec435f0 100644 --- a/src/jvm/src/test/kotlin/jvm/ParametersTest.kt +++ b/src/jvm/src/test/kotlin/jvm/ParametersTest.kt @@ -12,7 +12,7 @@ import kotlin.test.assertSame /** * Unit tests for the `Parameters` object */ -@DisplayName("Kotlin | Java | Parameters") +@DisplayName("JVM | Kotlin | Parameters") class ParametersTest { /** diff --git a/src/jvm/src/test/kotlin/jvm/integration/common/Custom.kt b/src/jvm/src/test/kotlin/jvm/integration/common/Custom.kt index 34a8160..19e0404 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/common/Custom.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/common/Custom.kt @@ -3,9 +3,9 @@ package solutions.bitbadger.documents.jvm.integration.common import solutions.bitbadger.documents.* import solutions.bitbadger.documents.extensions.* import solutions.bitbadger.documents.jvm.Results -import solutions.bitbadger.documents.query.Count -import solutions.bitbadger.documents.query.Delete -import solutions.bitbadger.documents.query.Find +import solutions.bitbadger.documents.query.CountQuery +import solutions.bitbadger.documents.query.DeleteQuery +import solutions.bitbadger.documents.query.FindQuery import solutions.bitbadger.documents.support.* import kotlin.test.assertEquals import kotlin.test.assertNotNull @@ -19,26 +19,26 @@ object Custom { fun listEmpty(db: ThrowawayDatabase) { JsonDocument.load(db) db.conn.deleteByFields(TEST_TABLE, listOf(Field.exists(Configuration.idField))) - val result = db.conn.customList(Find.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData) + val result = db.conn.customList(FindQuery.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData) assertEquals(0, result.size, "There should have been no results") } fun listAll(db: ThrowawayDatabase) { JsonDocument.load(db) - val result = db.conn.customList(Find.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData) + val result = db.conn.customList(FindQuery.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData) assertEquals(5, result.size, "There should have been 5 results") } fun singleNone(db: ThrowawayDatabase) = assertNull( - db.conn.customSingle(Find.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData), + db.conn.customSingle(FindQuery.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData), "There should not have been a document returned" ) fun singleOne(db: ThrowawayDatabase) { JsonDocument.load(db) assertNotNull( - db.conn.customSingle(Find.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData), + db.conn.customSingle(FindQuery.all(TEST_TABLE), listOf(), JsonDocument::class.java, Results::fromData), "There should not have been a document returned" ) } @@ -46,12 +46,12 @@ object Custom { fun nonQueryChanges(db: ThrowawayDatabase) { JsonDocument.load(db) assertEquals( - 5L, db.conn.customScalar(Count.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), + 5L, db.conn.customScalar(CountQuery.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), "There should have been 5 documents in the table" ) db.conn.customNonQuery("DELETE FROM $TEST_TABLE") assertEquals( - 0L, db.conn.customScalar(Count.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), + 0L, db.conn.customScalar(CountQuery.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), "There should have been no documents in the table" ) } @@ -59,15 +59,15 @@ object Custom { fun nonQueryNoChanges(db: ThrowawayDatabase) { JsonDocument.load(db) assertEquals( - 5L, db.conn.customScalar(Count.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), + 5L, db.conn.customScalar(CountQuery.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), "There should have been 5 documents in the table" ) db.conn.customNonQuery( - Delete.byId(TEST_TABLE, "eighty-two"), + DeleteQuery.byId(TEST_TABLE, "eighty-two"), listOf(Parameter(":id", ParameterType.STRING, "eighty-two")) ) assertEquals( - 5L, db.conn.customScalar(Count.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), + 5L, db.conn.customScalar(CountQuery.all(TEST_TABLE), listOf(), Long::class.java, Results::toCount), "There should still have been 5 documents in the table" ) } diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/DefinitionIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/DefinitionIT.kt index 298fb93..bb01c6c 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/DefinitionIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/DefinitionIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `Definition` object / `ensure*` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: Definition") +@DisplayName("JVM | Kotlin | PostgreSQL: Definition") class DefinitionIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/DeleteIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/DeleteIT.kt index be56697..8b322d0 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/DeleteIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/DeleteIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `Delete` object / `deleteBy*` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: Delete") +@DisplayName("JVM | Kotlin | PostgreSQL: Delete") class DeleteIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/DocumentIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/DocumentIT.kt index 478e9e1..ab3955c 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/DocumentIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/DocumentIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `Document` object / `insert`, `save`, `update` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: Document") +@DisplayName("JVM | Kotlin | PostgreSQL: Document") class DocumentIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/ExistsIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/ExistsIT.kt index 848962a..c41b14e 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/ExistsIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/ExistsIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `Exists` object / `existsBy*` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: Exists") +@DisplayName("JVM | Kotlin | PostgreSQL: Exists") class ExistsIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/FindIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/FindIT.kt index b6d8e98..32bf564 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/FindIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/FindIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `Find` object / `find*` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: Find") +@DisplayName("JVM | Kotlin | PostgreSQL: Find") class FindIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/PatchIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/PatchIT.kt index 7cedf46..4a9c2ee 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/PatchIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/PatchIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `Patch` object / `patchBy*` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: Patch") +@DisplayName("JVM | Kotlin | PostgreSQL: Patch") class PatchIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/postgresql/RemoveFieldsIT.kt b/src/jvm/src/test/kotlin/jvm/integration/postgresql/RemoveFieldsIT.kt index 4919ce8..968106f 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/postgresql/RemoveFieldsIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/postgresql/RemoveFieldsIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * PostgreSQL integration tests for the `RemoveFields` object / `removeFieldsBy*` connection extension functions */ -@DisplayName("Java | Kotlin | PostgreSQL: RemoveFields") +@DisplayName("JVM | Kotlin | PostgreSQL: RemoveFields") class RemoveFieldsIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/DefinitionIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/DefinitionIT.kt index 313eab5..bc47dc0 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/DefinitionIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/DefinitionIT.kt @@ -9,7 +9,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `Definition` object / `ensure*` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: Definition") +@DisplayName("JVM | Kotlin | SQLite: Definition") class DefinitionIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/DeleteIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/DeleteIT.kt index 7975e1a..bbdda99 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/DeleteIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/DeleteIT.kt @@ -9,7 +9,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `Delete` object / `deleteBy*` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: Delete") +@DisplayName("JVM | Kotlin | SQLite: Delete") class DeleteIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/DocumentIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/DocumentIT.kt index 414dbcd..1531117 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/DocumentIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/DocumentIT.kt @@ -7,7 +7,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `Document` object / `insert`, `save`, `update` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: Document") +@DisplayName("JVM | Kotlin | SQLite: Document") class DocumentIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/ExistsIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/ExistsIT.kt index 36b0bd4..b4b65f2 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/ExistsIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/ExistsIT.kt @@ -9,7 +9,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `Exists` object / `existsBy*` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: Exists") +@DisplayName("JVM | Kotlin | SQLite: Exists") class ExistsIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/FindIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/FindIT.kt index abe0aaa..8dab546 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/FindIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/FindIT.kt @@ -9,7 +9,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `Find` object / `find*` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: Find") +@DisplayName("JVM | Kotlin | SQLite: Find") class FindIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/PatchIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/PatchIT.kt index ac1d2c4..7918bef 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/PatchIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/PatchIT.kt @@ -9,7 +9,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `Patch` object / `patchBy*` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: Patch") +@DisplayName("JVM | Kotlin | SQLite: Patch") class PatchIT { @Test diff --git a/src/jvm/src/test/kotlin/jvm/integration/sqlite/RemoveFieldsIT.kt b/src/jvm/src/test/kotlin/jvm/integration/sqlite/RemoveFieldsIT.kt index 7518ab4..26e51b6 100644 --- a/src/jvm/src/test/kotlin/jvm/integration/sqlite/RemoveFieldsIT.kt +++ b/src/jvm/src/test/kotlin/jvm/integration/sqlite/RemoveFieldsIT.kt @@ -9,7 +9,7 @@ import kotlin.test.Test /** * SQLite integration tests for the `RemoveFields` object / `removeFieldsBy*` connection extension functions */ -@DisplayName("Java | Kotlin | SQLite: RemoveFields") +@DisplayName("JVM | Kotlin | SQLite: RemoveFields") class RemoveFieldsIT { @Test diff --git a/src/jvm/src/test/kotlin/query/CountTest.kt b/src/jvm/src/test/kotlin/query/CountQueryTest.kt similarity index 79% rename from src/jvm/src/test/kotlin/query/CountTest.kt rename to src/jvm/src/test/kotlin/query/CountQueryTest.kt index 7943110..9d2de61 100644 --- a/src/jvm/src/test/kotlin/query/CountTest.kt +++ b/src/jvm/src/test/kotlin/query/CountQueryTest.kt @@ -13,8 +13,8 @@ import kotlin.test.assertEquals /** * Unit tests for the `Count` object */ -@DisplayName("Kotlin | Common | Query: Count") -class CountTest { +@DisplayName("JVM | Kotlin | Query | CountQuery") +class CountQueryTest { /** Test table name */ private val tbl = "test_table" @@ -30,7 +30,7 @@ class CountTest { @Test @DisplayName("all generates correctly") fun all() = - assertEquals("SELECT COUNT(*) AS it FROM $tbl", Count.all(tbl), "Count query not constructed correctly") + assertEquals("SELECT COUNT(*) AS it FROM $tbl", CountQuery.all(tbl), "Count query not constructed correctly") @Test @DisplayName("byFields generates correctly (PostgreSQL)") @@ -38,7 +38,7 @@ class CountTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "SELECT COUNT(*) AS it FROM $tbl WHERE data->>'test' = :field0", - Count.byFields(tbl, listOf(Field.equal("test", "", ":field0"))), + CountQuery.byFields(tbl, listOf(Field.equal("test", "", ":field0"))), "Count query not constructed correctly" ) } @@ -49,7 +49,7 @@ class CountTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "SELECT COUNT(*) AS it FROM $tbl WHERE data->>'test' = :field0", - Count.byFields(tbl, listOf(Field.equal("test", "", ":field0"))), + CountQuery.byFields(tbl, listOf(Field.equal("test", "", ":field0"))), "Count query not constructed correctly" ) } @@ -59,7 +59,7 @@ class CountTest { fun byContainsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "SELECT COUNT(*) AS it FROM $tbl WHERE data @> :criteria", Count.byContains(tbl), + "SELECT COUNT(*) AS it FROM $tbl WHERE data @> :criteria", CountQuery.byContains(tbl), "Count query not constructed correctly" ) } @@ -68,7 +68,7 @@ class CountTest { @DisplayName("byContains fails (SQLite)") fun byContainsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Count.byContains(tbl) } + assertThrows { CountQuery.byContains(tbl) } } @Test @@ -77,7 +77,7 @@ class CountTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "SELECT COUNT(*) AS it FROM $tbl WHERE jsonb_path_exists(data, :path::jsonpath)", - Count.byJsonPath(tbl), "Count query not constructed correctly" + CountQuery.byJsonPath(tbl), "Count query not constructed correctly" ) } @@ -85,6 +85,6 @@ class CountTest { @DisplayName("byJsonPath fails (SQLite)") fun byJsonPathSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Count.byJsonPath(tbl) } + assertThrows { CountQuery.byJsonPath(tbl) } } } diff --git a/src/jvm/src/test/kotlin/query/DefinitionTest.kt b/src/jvm/src/test/kotlin/query/DefinitionQueryTest.kt similarity index 80% rename from src/jvm/src/test/kotlin/query/DefinitionTest.kt rename to src/jvm/src/test/kotlin/query/DefinitionQueryTest.kt index 4a37200..71d1fef 100644 --- a/src/jvm/src/test/kotlin/query/DefinitionTest.kt +++ b/src/jvm/src/test/kotlin/query/DefinitionQueryTest.kt @@ -13,8 +13,8 @@ import kotlin.test.assertEquals /** * Unit tests for the `Definition` object */ -@DisplayName("Kotlin | Common | Query: Definition") -class DefinitionTest { +@DisplayName("JVM | Kotlin | Query | DefinitionQuery") +class DefinitionQueryTest { /** Test table name */ private val tbl = "test_table" @@ -32,27 +32,27 @@ class DefinitionTest { fun ensureTableFor() = assertEquals( "CREATE TABLE IF NOT EXISTS my.table (data JSONB NOT NULL)", - Definition.ensureTableFor("my.table", "JSONB"), "CREATE TABLE statement not constructed correctly" + DefinitionQuery.ensureTableFor("my.table", "JSONB"), "CREATE TABLE statement not constructed correctly" ) @Test @DisplayName("ensureTable generates correctly (PostgreSQL)") fun ensureTablePostgres() { Configuration.dialectValue = Dialect.POSTGRESQL - assertEquals("CREATE TABLE IF NOT EXISTS $tbl (data JSONB NOT NULL)", Definition.ensureTable(tbl)) + assertEquals("CREATE TABLE IF NOT EXISTS $tbl (data JSONB NOT NULL)", DefinitionQuery.ensureTable(tbl)) } @Test @DisplayName("ensureTable generates correctly (SQLite)") fun ensureTableSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertEquals("CREATE TABLE IF NOT EXISTS $tbl (data TEXT NOT NULL)", Definition.ensureTable(tbl)) + assertEquals("CREATE TABLE IF NOT EXISTS $tbl (data TEXT NOT NULL)", DefinitionQuery.ensureTable(tbl)) } @Test @DisplayName("ensureTable fails when no dialect is set") fun ensureTableFailsUnknown() { - assertThrows { Definition.ensureTable(tbl) } + assertThrows { DefinitionQuery.ensureTable(tbl) } } @Test @@ -60,7 +60,7 @@ class DefinitionTest { fun ensureKeyWithSchema() = assertEquals( "CREATE UNIQUE INDEX IF NOT EXISTS idx_table_key ON test.table ((data->>'id'))", - Definition.ensureKey("test.table", Dialect.POSTGRESQL), + DefinitionQuery.ensureKey("test.table", Dialect.POSTGRESQL), "CREATE INDEX for key statement with schema not constructed correctly" ) @@ -69,7 +69,7 @@ class DefinitionTest { fun ensureKeyWithoutSchema() = assertEquals( "CREATE UNIQUE INDEX IF NOT EXISTS idx_${tbl}_key ON $tbl ((data->>'id'))", - Definition.ensureKey(tbl, Dialect.SQLITE), + DefinitionQuery.ensureKey(tbl, Dialect.SQLITE), "CREATE INDEX for key statement without schema not constructed correctly" ) @@ -78,7 +78,7 @@ class DefinitionTest { fun ensureIndexOnMultipleFields() = assertEquals( "CREATE INDEX IF NOT EXISTS idx_table_gibberish ON test.table ((data->>'taco'), (data->>'guac') DESC, (data->>'salsa') ASC)", - Definition.ensureIndexOn( + DefinitionQuery.ensureIndexOn( "test.table", "gibberish", listOf("taco", "guac DESC", "salsa ASC"), Dialect.POSTGRESQL ), @@ -90,7 +90,7 @@ class DefinitionTest { fun ensureIndexOnNestedPostgres() = assertEquals( "CREATE INDEX IF NOT EXISTS idx_${tbl}_nest ON $tbl ((data#>>'{a,b,c}'))", - Definition.ensureIndexOn(tbl, "nest", listOf("a.b.c"), Dialect.POSTGRESQL), + DefinitionQuery.ensureIndexOn(tbl, "nest", listOf("a.b.c"), Dialect.POSTGRESQL), "CREATE INDEX for nested PostgreSQL field incorrect" ) @@ -99,7 +99,7 @@ class DefinitionTest { fun ensureIndexOnNestedSQLite() = assertEquals( "CREATE INDEX IF NOT EXISTS idx_${tbl}_nest ON $tbl ((data->'a'->'b'->>'c'))", - Definition.ensureIndexOn(tbl, "nest", listOf("a.b.c"), Dialect.SQLITE), + DefinitionQuery.ensureIndexOn(tbl, "nest", listOf("a.b.c"), Dialect.SQLITE), "CREATE INDEX for nested SQLite field incorrect" ) @@ -109,7 +109,7 @@ class DefinitionTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "CREATE INDEX IF NOT EXISTS idx_${tbl}_document ON $tbl USING GIN (data)", - Definition.ensureDocumentIndexOn(tbl, DocumentIndex.FULL), + DefinitionQuery.ensureDocumentIndexOn(tbl, DocumentIndex.FULL), "CREATE INDEX for full document index incorrect" ) } @@ -120,7 +120,7 @@ class DefinitionTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "CREATE INDEX IF NOT EXISTS idx_${tbl}_document ON $tbl USING GIN (data jsonb_path_ops)", - Definition.ensureDocumentIndexOn(tbl, DocumentIndex.OPTIMIZED), + DefinitionQuery.ensureDocumentIndexOn(tbl, DocumentIndex.OPTIMIZED), "CREATE INDEX for optimized document index incorrect" ) } @@ -129,6 +129,6 @@ class DefinitionTest { @DisplayName("ensureDocumentIndexOn fails for SQLite") fun ensureDocumentIndexOnFailsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Definition.ensureDocumentIndexOn(tbl, DocumentIndex.FULL) } + assertThrows { DefinitionQuery.ensureDocumentIndexOn(tbl, DocumentIndex.FULL) } } } diff --git a/src/jvm/src/test/kotlin/query/DeleteTest.kt b/src/jvm/src/test/kotlin/query/DeleteQueryTest.kt similarity index 75% rename from src/jvm/src/test/kotlin/query/DeleteTest.kt rename to src/jvm/src/test/kotlin/query/DeleteQueryTest.kt index dfdd80a..330b816 100644 --- a/src/jvm/src/test/kotlin/query/DeleteTest.kt +++ b/src/jvm/src/test/kotlin/query/DeleteQueryTest.kt @@ -13,8 +13,8 @@ import kotlin.test.assertEquals /** * Unit tests for the `Delete` object */ -@DisplayName("Kotlin | Common | Query: Delete") -class DeleteTest { +@DisplayName("JVM | Kotlin | Query | DeleteQuery") +class DeleteQueryTest { /** Test table name */ private val tbl = "test_table" @@ -33,7 +33,7 @@ class DeleteTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "DELETE FROM $tbl WHERE data->>'id' = :id", - Delete.byId(tbl), "Delete query not constructed correctly" + DeleteQuery.byId(tbl), "Delete query not constructed correctly" ) } @@ -43,7 +43,7 @@ class DeleteTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "DELETE FROM $tbl WHERE data->>'id' = :id", - Delete.byId(tbl), "Delete query not constructed correctly" + DeleteQuery.byId(tbl), "Delete query not constructed correctly" ) } @@ -52,7 +52,7 @@ class DeleteTest { fun byFieldsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "DELETE FROM $tbl WHERE data->>'a' = :b", Delete.byFields(tbl, listOf(Field.equal("a", "", ":b"))), + "DELETE FROM $tbl WHERE data->>'a' = :b", DeleteQuery.byFields(tbl, listOf(Field.equal("a", "", ":b"))), "Delete query not constructed correctly" ) } @@ -62,7 +62,7 @@ class DeleteTest { fun byFieldsSQLite() { Configuration.dialectValue = Dialect.SQLITE assertEquals( - "DELETE FROM $tbl WHERE data->>'a' = :b", Delete.byFields(tbl, listOf(Field.equal("a", "", ":b"))), + "DELETE FROM $tbl WHERE data->>'a' = :b", DeleteQuery.byFields(tbl, listOf(Field.equal("a", "", ":b"))), "Delete query not constructed correctly" ) } @@ -72,7 +72,7 @@ class DeleteTest { fun byContainsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "DELETE FROM $tbl WHERE data @> :criteria", Delete.byContains(tbl), "Delete query not constructed correctly" + "DELETE FROM $tbl WHERE data @> :criteria", DeleteQuery.byContains(tbl), "Delete query not constructed correctly" ) } @@ -80,7 +80,7 @@ class DeleteTest { @DisplayName("byContains fails (SQLite)") fun byContainsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Delete.byContains(tbl) } + assertThrows { DeleteQuery.byContains(tbl) } } @Test @@ -88,7 +88,7 @@ class DeleteTest { fun byJsonPathPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "DELETE FROM $tbl WHERE jsonb_path_exists(data, :path::jsonpath)", Delete.byJsonPath(tbl), + "DELETE FROM $tbl WHERE jsonb_path_exists(data, :path::jsonpath)", DeleteQuery.byJsonPath(tbl), "Delete query not constructed correctly" ) } @@ -97,6 +97,6 @@ class DeleteTest { @DisplayName("byJsonPath fails (SQLite)") fun byJsonPathSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Delete.byJsonPath(tbl) } + assertThrows { DeleteQuery.byJsonPath(tbl) } } } diff --git a/src/jvm/src/test/kotlin/query/DocumentTest.kt b/src/jvm/src/test/kotlin/query/DocumentQueryTest.kt similarity index 85% rename from src/jvm/src/test/kotlin/query/DocumentTest.kt rename to src/jvm/src/test/kotlin/query/DocumentQueryTest.kt index 6566c7f..bb6d5bc 100644 --- a/src/jvm/src/test/kotlin/query/DocumentTest.kt +++ b/src/jvm/src/test/kotlin/query/DocumentQueryTest.kt @@ -14,8 +14,8 @@ import kotlin.test.assertTrue /** * Unit tests for the `Document` object */ -@DisplayName("Kotlin | Common | Query: Document") -class DocumentTest { +@DisplayName("JVM | Kotlin | Query | DocumentQuery") +class DocumentQueryTest { /** Test table name */ private val tbl = "test_table" @@ -32,14 +32,14 @@ class DocumentTest { @DisplayName("insert generates no auto ID (PostgreSQL)") fun insertNoAutoPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL - assertEquals("INSERT INTO $tbl VALUES (:data)", Document.insert(tbl)) + assertEquals("INSERT INTO $tbl VALUES (:data)", DocumentQuery.insert(tbl)) } @Test @DisplayName("insert generates no auto ID (SQLite)") fun insertNoAutoSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertEquals("INSERT INTO $tbl VALUES (:data)", Document.insert(tbl)) + assertEquals("INSERT INTO $tbl VALUES (:data)", DocumentQuery.insert(tbl)) } @Test @@ -49,7 +49,7 @@ class DocumentTest { assertEquals( "INSERT INTO $tbl VALUES (:data::jsonb || ('{\"id\":' " + "|| (SELECT COALESCE(MAX((data->>'id')::numeric), 0) + 1 FROM $tbl) || '}')::jsonb)", - Document.insert(tbl, AutoId.NUMBER) + DocumentQuery.insert(tbl, AutoId.NUMBER) ) } @@ -60,7 +60,7 @@ class DocumentTest { assertEquals( "INSERT INTO $tbl VALUES (json_set(:data, '$.id', " + "(SELECT coalesce(max(data->>'id'), 0) + 1 FROM $tbl)))", - Document.insert(tbl, AutoId.NUMBER) + DocumentQuery.insert(tbl, AutoId.NUMBER) ) } @@ -68,7 +68,7 @@ class DocumentTest { @DisplayName("insert generates auto UUID (PostgreSQL)") fun insertAutoUUIDPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL - val query = Document.insert(tbl, AutoId.UUID) + val query = DocumentQuery.insert(tbl, AutoId.UUID) assertTrue( query.startsWith("INSERT INTO $tbl VALUES (:data::jsonb || '{\"id\":\""), "Query start not correct (actual: $query)" @@ -80,7 +80,7 @@ class DocumentTest { @DisplayName("insert generates auto UUID (SQLite)") fun insertAutoUUIDSQLite() { Configuration.dialectValue = Dialect.SQLITE - val query = Document.insert(tbl, AutoId.UUID) + val query = DocumentQuery.insert(tbl, AutoId.UUID) assertTrue( query.startsWith("INSERT INTO $tbl VALUES (json_set(:data, '$.id', '"), "Query start not correct (actual: $query)" @@ -94,7 +94,7 @@ class DocumentTest { try { Configuration.dialectValue = Dialect.POSTGRESQL Configuration.idStringLength = 8 - val query = Document.insert(tbl, AutoId.RANDOM_STRING) + val query = DocumentQuery.insert(tbl, AutoId.RANDOM_STRING) assertTrue( query.startsWith("INSERT INTO $tbl VALUES (:data::jsonb || '{\"id\":\""), "Query start not correct (actual: $query)" @@ -114,7 +114,7 @@ class DocumentTest { @DisplayName("insert generates auto random string (SQLite)") fun insertAutoRandomSQLite() { Configuration.dialectValue = Dialect.SQLITE - val query = Document.insert(tbl, AutoId.RANDOM_STRING) + val query = DocumentQuery.insert(tbl, AutoId.RANDOM_STRING) assertTrue( query.startsWith("INSERT INTO $tbl VALUES (json_set(:data, '$.id', '"), "Query start not correct (actual: $query)" @@ -130,7 +130,7 @@ class DocumentTest { @Test @DisplayName("insert fails when no dialect is set") fun insertFailsUnknown() { - assertThrows { Document.insert(tbl) } + assertThrows { DocumentQuery.insert(tbl) } } @Test @@ -139,12 +139,12 @@ class DocumentTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "INSERT INTO $tbl VALUES (:data) ON CONFLICT ((data->>'id')) DO UPDATE SET data = EXCLUDED.data", - Document.save(tbl), "INSERT ON CONFLICT UPDATE statement not constructed correctly" + DocumentQuery.save(tbl), "INSERT ON CONFLICT UPDATE statement not constructed correctly" ) } @Test @DisplayName("update generates successfully") fun update() = - assertEquals("UPDATE $tbl SET data = :data", Document.update(tbl), "Update query not constructed correctly") + assertEquals("UPDATE $tbl SET data = :data", DocumentQuery.update(tbl), "Update query not constructed correctly") } diff --git a/src/jvm/src/test/kotlin/query/ExistsTest.kt b/src/jvm/src/test/kotlin/query/ExistsQueryTest.kt similarity index 82% rename from src/jvm/src/test/kotlin/query/ExistsTest.kt rename to src/jvm/src/test/kotlin/query/ExistsQueryTest.kt index fb22189..d9d09e2 100644 --- a/src/jvm/src/test/kotlin/query/ExistsTest.kt +++ b/src/jvm/src/test/kotlin/query/ExistsQueryTest.kt @@ -14,7 +14,7 @@ import kotlin.test.assertEquals * Unit tests for the `Exists` object */ @DisplayName("Kotlin | Common | Query: Exists") -class ExistsTest { +class ExistsQueryTest { /** Test table name */ private val tbl = "test_table" @@ -33,7 +33,7 @@ class ExistsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "SELECT EXISTS (SELECT 1 FROM $tbl WHERE data->>'id' = :id) AS it", - Exists.byId(tbl), "Exists query not constructed correctly" + ExistsQuery.byId(tbl), "Exists query not constructed correctly" ) } @@ -43,7 +43,7 @@ class ExistsTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "SELECT EXISTS (SELECT 1 FROM $tbl WHERE data->>'id' = :id) AS it", - Exists.byId(tbl), "Exists query not constructed correctly" + ExistsQuery.byId(tbl), "Exists query not constructed correctly" ) } @@ -53,7 +53,7 @@ class ExistsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "SELECT EXISTS (SELECT 1 FROM $tbl WHERE (data->>'it')::numeric = :test) AS it", - Exists.byFields(tbl, listOf(Field.equal("it", 7, ":test"))), + ExistsQuery.byFields(tbl, listOf(Field.equal("it", 7, ":test"))), "Exists query not constructed correctly" ) } @@ -64,7 +64,7 @@ class ExistsTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "SELECT EXISTS (SELECT 1 FROM $tbl WHERE data->>'it' = :test) AS it", - Exists.byFields(tbl, listOf(Field.equal("it", 7, ":test"))), + ExistsQuery.byFields(tbl, listOf(Field.equal("it", 7, ":test"))), "Exists query not constructed correctly" ) } @@ -74,7 +74,7 @@ class ExistsTest { fun byContainsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "SELECT EXISTS (SELECT 1 FROM $tbl WHERE data @> :criteria) AS it", Exists.byContains(tbl), + "SELECT EXISTS (SELECT 1 FROM $tbl WHERE data @> :criteria) AS it", ExistsQuery.byContains(tbl), "Exists query not constructed correctly" ) } @@ -83,7 +83,7 @@ class ExistsTest { @DisplayName("byContains fails (SQLite)") fun byContainsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Exists.byContains(tbl) } + assertThrows { ExistsQuery.byContains(tbl) } } @Test @@ -92,7 +92,7 @@ class ExistsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "SELECT EXISTS (SELECT 1 FROM $tbl WHERE jsonb_path_exists(data, :path::jsonpath)) AS it", - Exists.byJsonPath(tbl), "Exists query not constructed correctly" + ExistsQuery.byJsonPath(tbl), "Exists query not constructed correctly" ) } @@ -100,6 +100,6 @@ class ExistsTest { @DisplayName("byJsonPath fails (SQLite)") fun byJsonPathSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Exists.byJsonPath(tbl) } + assertThrows { ExistsQuery.byJsonPath(tbl) } } } diff --git a/src/jvm/src/test/kotlin/query/FindTest.kt b/src/jvm/src/test/kotlin/query/FindQueryTest.kt similarity index 63% rename from src/jvm/src/test/kotlin/query/FindTest.kt rename to src/jvm/src/test/kotlin/query/FindQueryTest.kt index 5ad3e5a..faeb505 100644 --- a/src/jvm/src/test/kotlin/query/FindTest.kt +++ b/src/jvm/src/test/kotlin/query/FindQueryTest.kt @@ -8,16 +8,14 @@ import solutions.bitbadger.documents.Configuration import solutions.bitbadger.documents.Dialect import solutions.bitbadger.documents.DocumentException import solutions.bitbadger.documents.Field +import solutions.bitbadger.documents.support.TEST_TABLE import kotlin.test.assertEquals /** * Unit tests for the `Find` object */ -@DisplayName("Kotlin | Common | Query: Find") -class FindTest { - - /** Test table name */ - private val tbl = "test_table" +@DisplayName("JVM | Kotlin | Query | FindQuery") +class FindQueryTest { /** * Clear the connection string (resets Dialect) @@ -30,15 +28,15 @@ class FindTest { @Test @DisplayName("all generates correctly") fun all() = - assertEquals("SELECT data FROM $tbl", Find.all(tbl), "Find query not constructed correctly") + assertEquals("SELECT data FROM $TEST_TABLE", FindQuery.all(TEST_TABLE), "Find query not constructed correctly") @Test @DisplayName("byId generates correctly (PostgreSQL)") fun byIdPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "SELECT data FROM $tbl WHERE data->>'id' = :id", - Find.byId(tbl), "Find query not constructed correctly" + "SELECT data FROM $TEST_TABLE WHERE data->>'id' = :id", + FindQuery.byId(TEST_TABLE), "Find query not constructed correctly" ) } @@ -47,8 +45,8 @@ class FindTest { fun byIdSQLite() { Configuration.dialectValue = Dialect.SQLITE assertEquals( - "SELECT data FROM $tbl WHERE data->>'id' = :id", - Find.byId(tbl), "Find query not constructed correctly" + "SELECT data FROM $TEST_TABLE WHERE data->>'id' = :id", + FindQuery.byId(TEST_TABLE), "Find query not constructed correctly" ) } @@ -57,8 +55,8 @@ class FindTest { fun byFieldsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "SELECT data FROM $tbl WHERE data->>'a' = :b AND (data->>'c')::numeric < :d", - Find.byFields(tbl, listOf(Field.equal("a", "", ":b"), Field.less("c", 14, ":d"))), + "SELECT data FROM $TEST_TABLE WHERE data->>'a' = :b AND (data->>'c')::numeric < :d", + FindQuery.byFields(TEST_TABLE, listOf(Field.equal("a", "", ":b"), Field.less("c", 14, ":d"))), "Find query not constructed correctly" ) } @@ -68,8 +66,8 @@ class FindTest { fun byFieldsSQLite() { Configuration.dialectValue = Dialect.SQLITE assertEquals( - "SELECT data FROM $tbl WHERE data->>'a' = :b AND data->>'c' < :d", - Find.byFields(tbl, listOf(Field.equal("a", "", ":b"), Field.less("c", 14, ":d"))), + "SELECT data FROM $TEST_TABLE WHERE data->>'a' = :b AND data->>'c' < :d", + FindQuery.byFields(TEST_TABLE, listOf(Field.equal("a", "", ":b"), Field.less("c", 14, ":d"))), "Find query not constructed correctly" ) } @@ -79,7 +77,7 @@ class FindTest { fun byContainsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "SELECT data FROM $tbl WHERE data @> :criteria", Find.byContains(tbl), + "SELECT data FROM $TEST_TABLE WHERE data @> :criteria", FindQuery.byContains(TEST_TABLE), "Find query not constructed correctly" ) } @@ -88,7 +86,7 @@ class FindTest { @DisplayName("byContains fails (SQLite)") fun byContainsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Find.byContains(tbl) } + assertThrows { FindQuery.byContains(TEST_TABLE) } } @Test @@ -96,7 +94,8 @@ class FindTest { fun byJsonPathPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "SELECT data FROM $tbl WHERE jsonb_path_exists(data, :path::jsonpath)", Find.byJsonPath(tbl), + "SELECT data FROM $TEST_TABLE WHERE jsonb_path_exists(data, :path::jsonpath)", + FindQuery.byJsonPath(TEST_TABLE), "Find query not constructed correctly" ) } @@ -105,6 +104,6 @@ class FindTest { @DisplayName("byJsonPath fails (SQLite)") fun byJsonPathSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Find.byJsonPath(tbl) } + assertThrows { FindQuery.byJsonPath(TEST_TABLE) } } } diff --git a/src/jvm/src/test/kotlin/query/PatchTest.kt b/src/jvm/src/test/kotlin/query/PatchQueryTest.kt similarity index 80% rename from src/jvm/src/test/kotlin/query/PatchTest.kt rename to src/jvm/src/test/kotlin/query/PatchQueryTest.kt index fd0cfad..0afcdf8 100644 --- a/src/jvm/src/test/kotlin/query/PatchTest.kt +++ b/src/jvm/src/test/kotlin/query/PatchQueryTest.kt @@ -13,8 +13,8 @@ import kotlin.test.assertEquals /** * Unit tests for the `Patch` object */ -@DisplayName("Kotlin | Common | Query: Patch") -class PatchTest { +@DisplayName("JVM | Kotlin | Query | PatchQuery") +class PatchQueryTest { /** Test table name */ private val tbl = "test_table" @@ -33,7 +33,7 @@ class PatchTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data || :data WHERE data->>'id' = :id", - Patch.byId(tbl), "Patch query not constructed correctly" + PatchQuery.byId(tbl), "Patch query not constructed correctly" ) } @@ -43,7 +43,7 @@ class PatchTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "UPDATE $tbl SET data = json_patch(data, json(:data)) WHERE data->>'id' = :id", - Patch.byId(tbl), "Patch query not constructed correctly" + PatchQuery.byId(tbl), "Patch query not constructed correctly" ) } @@ -53,7 +53,7 @@ class PatchTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data || :data WHERE data->>'z' = :y", - Patch.byFields(tbl, listOf(Field.equal("z", "", ":y"))), + PatchQuery.byFields(tbl, listOf(Field.equal("z", "", ":y"))), "Patch query not constructed correctly" ) } @@ -64,7 +64,7 @@ class PatchTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "UPDATE $tbl SET data = json_patch(data, json(:data)) WHERE data->>'z' = :y", - Patch.byFields(tbl, listOf(Field.equal("z", "", ":y"))), + PatchQuery.byFields(tbl, listOf(Field.equal("z", "", ":y"))), "Patch query not constructed correctly" ) } @@ -74,7 +74,7 @@ class PatchTest { fun byContainsPostgres() { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( - "UPDATE $tbl SET data = data || :data WHERE data @> :criteria", Patch.byContains(tbl), + "UPDATE $tbl SET data = data || :data WHERE data @> :criteria", PatchQuery.byContains(tbl), "Patch query not constructed correctly" ) } @@ -83,7 +83,7 @@ class PatchTest { @DisplayName("byContains fails (SQLite)") fun byContainsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Patch.byContains(tbl) } + assertThrows { PatchQuery.byContains(tbl) } } @Test @@ -92,7 +92,7 @@ class PatchTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data || :data WHERE jsonb_path_exists(data, :path::jsonpath)", - Patch.byJsonPath(tbl), "Patch query not constructed correctly" + PatchQuery.byJsonPath(tbl), "Patch query not constructed correctly" ) } @@ -100,6 +100,6 @@ class PatchTest { @DisplayName("byJsonPath fails (SQLite)") fun byJsonPathSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { Patch.byJsonPath(tbl) } + assertThrows { PatchQuery.byJsonPath(tbl) } } } diff --git a/src/jvm/src/test/kotlin/query/QueryTest.kt b/src/jvm/src/test/kotlin/query/QueryTest.kt index 6788ac4..c16b31a 100644 --- a/src/jvm/src/test/kotlin/query/QueryTest.kt +++ b/src/jvm/src/test/kotlin/query/QueryTest.kt @@ -10,9 +10,9 @@ import solutions.bitbadger.documents.FieldMatch import kotlin.test.assertEquals /** - * Unit tests for the top-level query functions + * Unit tests for the package-level query functions */ -@DisplayName("Kotlin | Common | Query") +@DisplayName("JVM | Kotlin | Query | Package Functions") class QueryTest { /** diff --git a/src/jvm/src/test/kotlin/query/RemoveFieldsTest.kt b/src/jvm/src/test/kotlin/query/RemoveFieldsQueryTest.kt similarity index 82% rename from src/jvm/src/test/kotlin/query/RemoveFieldsTest.kt rename to src/jvm/src/test/kotlin/query/RemoveFieldsQueryTest.kt index 34fce2d..d042f17 100644 --- a/src/jvm/src/test/kotlin/query/RemoveFieldsTest.kt +++ b/src/jvm/src/test/kotlin/query/RemoveFieldsQueryTest.kt @@ -10,8 +10,8 @@ import kotlin.test.assertEquals /** * Unit tests for the `RemoveFields` object */ -@DisplayName("Kotlin | Common | Query: RemoveFields") -class RemoveFieldsTest { +@DisplayName("JVM | Kotlin | Query | RemoveFieldsQuery") +class RemoveFieldsQueryTest { /** Test table name */ private val tbl = "test_table" @@ -30,7 +30,7 @@ class RemoveFieldsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data - :name::text[] WHERE data->>'id' = :id", - RemoveFields.byId(tbl, listOf(Parameter(":name", ParameterType.STRING, "{a,z}"))), + RemoveFieldsQuery.byId(tbl, listOf(Parameter(":name", ParameterType.STRING, "{a,z}"))), "Remove Fields query not constructed correctly" ) } @@ -41,7 +41,7 @@ class RemoveFieldsTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "UPDATE $tbl SET data = json_remove(data, :name0, :name1) WHERE data->>'id' = :id", - RemoveFields.byId( + RemoveFieldsQuery.byId( tbl, listOf( Parameter(":name0", ParameterType.STRING, "a"), @@ -58,7 +58,7 @@ class RemoveFieldsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data - :name::text[] WHERE data->>'f' > :g", - RemoveFields.byFields( + RemoveFieldsQuery.byFields( tbl, listOf(Parameter(":name", ParameterType.STRING, "{b,c}")), listOf(Field.greater("f", "", ":g")) @@ -73,7 +73,7 @@ class RemoveFieldsTest { Configuration.dialectValue = Dialect.SQLITE assertEquals( "UPDATE $tbl SET data = json_remove(data, :name0, :name1) WHERE data->>'f' > :g", - RemoveFields.byFields( + RemoveFieldsQuery.byFields( tbl, listOf(Parameter(":name0", ParameterType.STRING, "b"), Parameter(":name1", ParameterType.STRING, "c")), listOf(Field.greater("f", "", ":g")) @@ -88,7 +88,7 @@ class RemoveFieldsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data - :name::text[] WHERE data @> :criteria", - RemoveFields.byContains(tbl, listOf(Parameter(":name", ParameterType.STRING, "{m,n}"))), + RemoveFieldsQuery.byContains(tbl, listOf(Parameter(":name", ParameterType.STRING, "{m,n}"))), "Remove Field query not constructed correctly" ) } @@ -97,7 +97,7 @@ class RemoveFieldsTest { @DisplayName("byContains fails (SQLite)") fun byContainsSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { RemoveFields.byContains(tbl, listOf()) } + assertThrows { RemoveFieldsQuery.byContains(tbl, listOf()) } } @Test @@ -106,7 +106,7 @@ class RemoveFieldsTest { Configuration.dialectValue = Dialect.POSTGRESQL assertEquals( "UPDATE $tbl SET data = data - :name::text[] WHERE jsonb_path_exists(data, :path::jsonpath)", - RemoveFields.byJsonPath(tbl, listOf(Parameter(":name", ParameterType.STRING, "{o,p}"))), + RemoveFieldsQuery.byJsonPath(tbl, listOf(Parameter(":name", ParameterType.STRING, "{o,p}"))), "Remove Field query not constructed correctly" ) } @@ -115,6 +115,6 @@ class RemoveFieldsTest { @DisplayName("byJsonPath fails (SQLite)") fun byJsonPathSQLite() { Configuration.dialectValue = Dialect.SQLITE - assertThrows { RemoveFields.byJsonPath(tbl, listOf()) } + assertThrows { RemoveFieldsQuery.byJsonPath(tbl, listOf()) } } } \ No newline at end of file diff --git a/src/jvm/src/test/kotlin/query/WhereTest.kt b/src/jvm/src/test/kotlin/query/WhereTest.kt index cdac60d..95d68d8 100644 --- a/src/jvm/src/test/kotlin/query/WhereTest.kt +++ b/src/jvm/src/test/kotlin/query/WhereTest.kt @@ -10,7 +10,7 @@ import kotlin.test.assertEquals /** * Unit tests for the `Where` object */ -@DisplayName("Kotlin | Common | Query: Where") +@DisplayName("JVM | Kotlin | Query | Where") class WhereTest { /** diff --git a/src/jvm/src/test/kotlin/support/Types.kt b/src/jvm/src/test/kotlin/support/Types.kt index 97385e2..d56f23b 100644 --- a/src/jvm/src/test/kotlin/support/Types.kt +++ b/src/jvm/src/test/kotlin/support/Types.kt @@ -1,22 +1,18 @@ package solutions.bitbadger.documents.support -import kotlinx.serialization.Serializable import solutions.bitbadger.documents.extensions.insert /** The test table name to use for integration tests */ const val TEST_TABLE = "test_table" -@Serializable data class NumIdDocument(val key: Int, val text: String) { constructor() : this(0, "") } -@Serializable data class SubDocument(val foo: String, val bar: String) { constructor() : this("", "") } -@Serializable data class ArrayDocument(val id: String, val values: List) { constructor() : this("", listOf()) @@ -31,7 +27,6 @@ data class ArrayDocument(val id: String, val values: List) { } } -@Serializable data class JsonDocument(val id: String, val value: String = "", val numValue: Int = 0, val sub: SubDocument? = null) { constructor() : this("") @@ -50,3 +45,11 @@ data class JsonDocument(val id: String, val value: String = "", val numValue: In testDocuments.forEach { db.conn.insert(tableName, it) } } } + +// Test classes for AutoId generation + +data class ByteIdClass(val id: Byte) +data class ShortIdClass(val id: Short) +data class IntIdClass(val id: Int) +data class LongIdClass(val id: Long) +data class StringIdClass(val id: String) diff --git a/src/kotlin/pom.xml b/src/kotlin/pom.xml index 9889629..5549ee3 100644 --- a/src/kotlin/pom.xml +++ b/src/kotlin/pom.xml @@ -30,8 +30,6 @@ solutions.bitbadger.documents jvm 4.0.0-alpha1-SNAPSHOT - system - ${project.basedir}/../jvm/target/jvm-4.0.0-alpha1-SNAPSHOT.jar jar diff --git a/src/kotlin/src/main/kotlin/Count.kt b/src/kotlin/src/main/kotlin/Count.kt index d8fbf7b..c3b3ef5 100644 --- a/src/kotlin/src/main/kotlin/Count.kt +++ b/src/kotlin/src/main/kotlin/Count.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.kotlin import solutions.bitbadger.documents.* import solutions.bitbadger.documents.kotlin.extensions.* -import solutions.bitbadger.documents.query.Count +import solutions.bitbadger.documents.query.CountQuery import java.sql.Connection @@ -19,7 +19,7 @@ object Count { * @return A count of the documents in the table */ fun all(tableName: String, conn: Connection) = - conn.customScalar(Count.all(tableName), mapFunc = Results::toCount) + conn.customScalar(CountQuery.all(tableName), mapFunc = Results::toCount) /** * Count all documents in the table @@ -47,7 +47,7 @@ object Count { ): Long { val named = Parameters.nameFields(fields) return conn.customScalar( - Count.byFields(tableName, named, howMatched), + CountQuery.byFields(tableName, named, howMatched), Parameters.addFields(named), Results::toCount ) @@ -74,7 +74,7 @@ object Count { * @throws DocumentException If called on a SQLite connection */ inline fun byContains(tableName: String, criteria: TContains, conn: Connection) = - conn.customScalar(Count.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), Results::toCount) + conn.customScalar(CountQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), Results::toCount) /** * Count documents using a JSON containment query (PostgreSQL only) @@ -98,7 +98,7 @@ object Count { */ fun byJsonPath(tableName: String, path: String, conn: Connection) = conn.customScalar( - Count.byJsonPath(tableName), + CountQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path)), Results::toCount ) diff --git a/src/kotlin/src/main/kotlin/Delete.kt b/src/kotlin/src/main/kotlin/Delete.kt index e670d48..9cdaa42 100644 --- a/src/kotlin/src/main/kotlin/Delete.kt +++ b/src/kotlin/src/main/kotlin/Delete.kt @@ -3,7 +3,7 @@ package solutions.bitbadger.documents.kotlin import solutions.bitbadger.documents.* import solutions.bitbadger.documents.jvm.Delete as JvmDelete import solutions.bitbadger.documents.kotlin.extensions.* -import solutions.bitbadger.documents.query.Delete +import solutions.bitbadger.documents.query.DeleteQuery import java.sql.Connection /** @@ -60,7 +60,7 @@ object Delete { * @throws DocumentException If called on a SQLite connection */ inline fun byContains(tableName: String, criteria: TContains, conn: Connection) = - conn.customNonQuery(Delete.byContains(tableName), listOf(Parameters.json(":criteria", criteria))) + conn.customNonQuery(DeleteQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria))) /** * Delete documents using a JSON containment query (PostgreSQL only) diff --git a/src/kotlin/src/main/kotlin/Document.kt b/src/kotlin/src/main/kotlin/Document.kt index 2c2547e..4b391b3 100644 --- a/src/kotlin/src/main/kotlin/Document.kt +++ b/src/kotlin/src/main/kotlin/Document.kt @@ -5,7 +5,7 @@ import solutions.bitbadger.documents.Configuration import solutions.bitbadger.documents.Dialect import solutions.bitbadger.documents.Field import solutions.bitbadger.documents.extensions.customNonQuery -import solutions.bitbadger.documents.query.Document +import solutions.bitbadger.documents.query.DocumentQuery import solutions.bitbadger.documents.query.Where import solutions.bitbadger.documents.query.statementWhere import java.sql.Connection @@ -25,7 +25,7 @@ object Document { inline fun insert(tableName: String, document: TDoc, conn: Connection) { val strategy = Configuration.autoIdStrategy val query = if (strategy == AutoId.DISABLED) { - Document.insert(tableName) + DocumentQuery.insert(tableName) } else { val idField = Configuration.idField val dialect = Configuration.dialect("Create auto-ID insert query") @@ -52,7 +52,7 @@ object Document { ":data" } - Document.insert(tableName).replace(":data", dataParam) + DocumentQuery.insert(tableName).replace(":data", dataParam) } conn.customNonQuery(query, listOf(Parameters.json(":data", document))) } @@ -74,7 +74,7 @@ object Document { * @param conn The connection on which the query should be executed */ inline fun save(tableName: String, document: TDoc, conn: Connection) = - conn.customNonQuery(Document.save(tableName), listOf(Parameters.json(":data", document))) + conn.customNonQuery(DocumentQuery.save(tableName), listOf(Parameters.json(":data", document))) /** * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert") @@ -95,7 +95,7 @@ object Document { */ inline fun update(tableName: String, docId: TKey, document: TDoc, conn: Connection) = conn.customNonQuery( - statementWhere(Document.update(tableName), Where.byId(":id", docId)), + statementWhere(DocumentQuery.update(tableName), Where.byId(":id", docId)), Parameters.addFields( listOf(Field.equal(Configuration.idField, docId, ":id")), mutableListOf(Parameters.json(":data", document)) diff --git a/src/kotlin/src/main/kotlin/Exists.kt b/src/kotlin/src/main/kotlin/Exists.kt index e253bbb..4cbc05b 100644 --- a/src/kotlin/src/main/kotlin/Exists.kt +++ b/src/kotlin/src/main/kotlin/Exists.kt @@ -3,7 +3,7 @@ package solutions.bitbadger.documents.kotlin import solutions.bitbadger.documents.* import solutions.bitbadger.documents.jvm.Exists as JvmExists import solutions.bitbadger.documents.kotlin.extensions.* -import solutions.bitbadger.documents.query.Exists +import solutions.bitbadger.documents.query.ExistsQuery import java.sql.Connection /** @@ -66,7 +66,7 @@ object Exists { */ inline fun byContains(tableName: String, criteria: TContains, conn: Connection) = conn.customScalar( - Exists.byContains(tableName), + ExistsQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria)), Results::toExists ) diff --git a/src/kotlin/src/main/kotlin/Find.kt b/src/kotlin/src/main/kotlin/Find.kt index a9ecf18..37af42a 100644 --- a/src/kotlin/src/main/kotlin/Find.kt +++ b/src/kotlin/src/main/kotlin/Find.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.kotlin import solutions.bitbadger.documents.* import solutions.bitbadger.documents.kotlin.extensions.* -import solutions.bitbadger.documents.query.Find +import solutions.bitbadger.documents.query.FindQuery import solutions.bitbadger.documents.query.orderBy import java.sql.Connection @@ -20,7 +20,7 @@ object Find { * @return A list of documents from the given table */ inline fun all(tableName: String, orderBy: Collection>? = null, conn: Connection) = - conn.customList(Find.all(tableName) + (orderBy?.let(::orderBy) ?: ""), mapFunc = Results::fromData) + conn.customList(FindQuery.all(tableName) + (orderBy?.let(::orderBy) ?: ""), mapFunc = Results::fromData) /** * Retrieve all documents in the given table @@ -52,7 +52,7 @@ object Find { */ inline fun byId(tableName: String, docId: TKey, conn: Connection) = conn.customSingle( - Find.byId(tableName, docId), + FindQuery.byId(tableName, docId), Parameters.addFields(listOf(Field.equal(Configuration.idField, docId, ":id"))), Results::fromData ) @@ -86,7 +86,7 @@ object Find { ): List { val named = Parameters.nameFields(fields) return conn.customList( - Find.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), Parameters.addFields(named), Results::fromData ) @@ -158,7 +158,7 @@ object Find { conn: Connection ) = conn.customList( - Find.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameters.json(":criteria", criteria)), Results::fromData ) @@ -223,7 +223,7 @@ object Find { conn: Connection ) = conn.customList( - Find.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameter(":path", ParameterType.STRING, path)), Results::fromData ) @@ -271,7 +271,7 @@ object Find { ): TDoc? { val named = Parameters.nameFields(fields) return conn.customSingle( - Find.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byFields(tableName, named, howMatched) + (orderBy?.let(::orderBy) ?: ""), Parameters.addFields(named), Results::fromData ) @@ -328,7 +328,7 @@ object Find { conn: Connection ) = conn.customSingle( - Find.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byContains(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameters.json(":criteria", criteria)), Results::fromData ) @@ -382,7 +382,7 @@ object Find { conn: Connection ) = conn.customSingle( - Find.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), + FindQuery.byJsonPath(tableName) + (orderBy?.let(::orderBy) ?: ""), listOf(Parameter(":path", ParameterType.STRING, path)), Results::fromData ) diff --git a/src/kotlin/src/main/kotlin/Patch.kt b/src/kotlin/src/main/kotlin/Patch.kt index 097eb2d..e4e4041 100644 --- a/src/kotlin/src/main/kotlin/Patch.kt +++ b/src/kotlin/src/main/kotlin/Patch.kt @@ -2,7 +2,7 @@ package solutions.bitbadger.documents.kotlin import solutions.bitbadger.documents.* import solutions.bitbadger.documents.kotlin.extensions.* -import solutions.bitbadger.documents.query.Patch +import solutions.bitbadger.documents.query.PatchQuery import java.sql.Connection /** @@ -20,7 +20,7 @@ object Patch { */ inline fun byId(tableName: String, docId: TKey, patch: TPatch, conn: Connection) = conn.customNonQuery( - Patch.byId(tableName, docId), + PatchQuery.byId(tableName, docId), Parameters.addFields( listOf(Field.equal(Configuration.idField, docId, ":id")), mutableListOf(Parameters.json(":data", patch)) @@ -55,7 +55,7 @@ object Patch { ) { val named = Parameters.nameFields(fields) conn.customNonQuery( - Patch.byFields(tableName, named, howMatched), Parameters.addFields( + PatchQuery.byFields(tableName, named, howMatched), Parameters.addFields( named, mutableListOf(Parameters.json(":data", patch)) ) @@ -94,7 +94,7 @@ object Patch { conn: Connection ) = conn.customNonQuery( - Patch.byContains(tableName), + PatchQuery.byContains(tableName), listOf(Parameters.json(":criteria", criteria), Parameters.json(":data", patch)) ) @@ -120,7 +120,7 @@ object Patch { */ inline fun byJsonPath(tableName: String, path: String, patch: TPatch, conn: Connection) = conn.customNonQuery( - Patch.byJsonPath(tableName), + PatchQuery.byJsonPath(tableName), listOf(Parameter(":path", ParameterType.STRING, path), Parameters.json(":data", patch)) ) diff --git a/src/kotlin/src/main/kotlin/RemoveFields.kt b/src/kotlin/src/main/kotlin/RemoveFields.kt index f1c7675..f24d855 100644 --- a/src/kotlin/src/main/kotlin/RemoveFields.kt +++ b/src/kotlin/src/main/kotlin/RemoveFields.kt @@ -3,7 +3,7 @@ package solutions.bitbadger.documents.kotlin import solutions.bitbadger.documents.* import solutions.bitbadger.documents.jvm.RemoveFields as JvmRemoveFields import solutions.bitbadger.documents.kotlin.extensions.* -import solutions.bitbadger.documents.query.RemoveFields +import solutions.bitbadger.documents.query.RemoveFieldsQuery import java.sql.Connection /** @@ -83,7 +83,7 @@ object RemoveFields { ) { val nameParams = Parameters.fieldNames(toRemove) conn.customNonQuery( - RemoveFields.byContains(tableName, nameParams), + RemoveFieldsQuery.byContains(tableName, nameParams), listOf(Parameters.json(":criteria", criteria), *nameParams.toTypedArray()) ) } diff --git a/src/kotlin/src/test/kotlin/Types.kt b/src/kotlin/src/test/kotlin/Types.kt new file mode 100644 index 0000000..51d0b38 --- /dev/null +++ b/src/kotlin/src/test/kotlin/Types.kt @@ -0,0 +1,52 @@ +package solutions.bitbadger.documents.kotlin + +import kotlinx.serialization.Serializable +import solutions.bitbadger.documents.extensions.insert + +/** The test table name to use for integration tests */ +const val TEST_TABLE = "test_table" + +@Serializable +data class NumIdDocument(val key: Int, val text: String) { + constructor() : this(0, "") +} + +@Serializable +data class SubDocument(val foo: String, val bar: String) { + constructor() : this("", "") +} + +@Serializable +data class ArrayDocument(val id: String, val values: List) { + + constructor() : this("", listOf()) + + companion object { + /** A set of documents used for integration tests */ + val testDocuments = listOf( + ArrayDocument("first", listOf("a", "b", "c")), + ArrayDocument("second", listOf("c", "d", "e")), + ArrayDocument("third", listOf("x", "y", "z")) + ) + } +} + +@Serializable +data class JsonDocument(val id: String, val value: String = "", val numValue: Int = 0, val sub: SubDocument? = null) { + + constructor() : this("") + + companion object { + /** Documents to use for testing */ + private val testDocuments = listOf( + JsonDocument("one", "FIRST!", 0, null), + JsonDocument("two", "another", 10, SubDocument("green", "blue")), + JsonDocument("three", "", 4, null), + JsonDocument("four", "purple", 17, SubDocument("green", "red")), + JsonDocument("five", "purple", 18, null) + ) + +// fun load(db: ThrowawayDatabase, tableName: String = TEST_TABLE) = +// testDocuments.forEach { db.conn.insert(tableName, it) } + } +}