# solutions.bitbadger.documents Treat PostgreSQL and SQLite as document stores from Java, Kotlin, Scala, and Groovy ## Examples ```java // Retrieve (find) all orders (Java) public List findOrders(Connection conn) { Find.all(/*table name*/ "order", /*type*/ Order.class, conn); } ``` ```kotlin // Mark an order as fulfilled (Kotlin) fun markFulfilled(orderId: Long, conn: Connection) = conn.patchById( /*table name*/ "order", /*document ID*/ orderId, /*patch object*/ mapOf("fulfilled" to true) ) ``` ```scala // Delete orders marked as obsolete (Scala) def deleteObsolete(Connection conn): conn.deleteByFields(/*table name*/ "order", /*field criteria*/ Field.equal("obsolete", true) :: Nil) ``` ```groovy // Remove the pending status from multiple orders (Groovy) void clearPending(List orderIds, Connection conn) { conn.removeFieldsByFields(/*table name*/ "order", /*field criteria*/ List.of(Field.any("id", orderIds)), /*fields to remove*/ List.of("pending")) } ``` ## Packages / Modules * The `core` module provides the base implementation and can be used from any JVM language. * The `solutions.bitbadger.documents` package contains support types like `Configuration` and `Field`. * The `solutions.bitbadger.documents.java` package contains document access functions and serialization config. * The `solutions.bitbadger.documents.java.extensions` package contains extensions on the JDBC `Connection` object, callable as extension methods from Kotlin or as static functions from other languages. * The `groovy` module packages the extension methods so that Groovy can access them. No other packages will need to be imported; they will show up on any `Connection` instance. * The `kotlinx` module utilizes the kotlinx-serialization project for its JSON serialization, which requires a different serializer and different function/method signatures (`inline fun ...` vs. `fun ...`). * `solutions.bitbadger.documents.kotlinx` and `solutions.bitbadger.documents.kotlinx.extensions` packages expose a similar API to their `java` counterparts, but one designed to be consumed from Kotlin. Generally, document retrieval functions will require a generic parameter instead of a `Class` parameter. * The `scala` module extends `core` by utilizing Scala's implicit `ClassTag`s to remove the `Class[T]` parameter. * `solutions.bitbadger.documents.scala` and `solutions.bitbadger.documents.scala.extensions` packages expose the same API as their `java` counterparts, utilizing Scala collections and `Option`s instead of Java collections and `Optional`s.