Accessing a Persistent Collection

Accessing a Persistent Collection

Accessing a Persistent Collection

In HexArc, a PersistentCollection provides four methods corresponding to the CRUD operations for accessing and updating its data, namely create, read, update and delete.

The way a service can interact with a specific PersistentCollection depends on the QueryLanguage of the PersistentCollection. Still, every QueryLanguage defines four types of queries corresponding to the CRUD operations:

CreateQuery: a query for creating entities;
ReadQuery: a query for reading entities;
UpdateQuery: a query for updating entities;
DeleteQuery: a query for deleting entities.

Together with the types of queries, a QueryLanguage defines the types of their results, namely CreateQueryResult, ReadQueryResult, UpdateQueryResult and DeleteQueryResult.

All these types can be accessed from the reference to the PersistentCollection created by the user.

Examples

This section will present a set of examples that show how to access a PersistentCollection, referring to the MongoDBPersistentCollection implementation.

Note: the query types defined by the MongoDBQueryLanguage used by the MongoDBPersistentCollection are integrated with Mongo Java Driver, so it is possible to define queries using its DSL.

Create one

import io.github.jahrim.hexarc.persistence.mongodb.MongoDBPersistentCollection
import io.github.jahrim.hexarc.persistence.mongodb.language.queries.CreateQuery

// Mongo Java Driver
import com.mongodb.client.model.{Filters, Projections, Updates, Aggregates}
import org.bson.{BsonDocument, BsonString}

// Create a `PersistentCollection`
val userCollection: MongoDBPersistentCollection = ???

// Use the `PersistentCollection`
type QueryResult = userCollection.CreateQueryResult
val queryResult: Try[QueryResult] = 
  userCollection.create(
    CreateQuery(
      document = 
        BsonDocument()
          .append("username", BsonString("Marco"))
          .append("email", BsonString("marco@hexarc.com"))
    )
  )

Create many

import io.github.jahrim.hexarc.persistence.mongodb.language.queries.CreateQuery
import com.mongodb.client.model.{Filters, Projections, Updates, Aggregates}
import org.bson.{BsonDocument, BsonString}

type QueryResult = userCollection.CreateQueryResult
val queryResult: Try[QueryResult] = 
  userCollection.create(
    CreateQuery.many(
      documents = Seq(
        BsonDocument()
          .append("username", BsonString("Marco"))
          .append("email", BsonString("marco@hexarc.com")),
        BsonDocument()
          .append("username", BsonString("Giovanni"))
          .append("email", BsonString("giovanni@hexarc.com"))
      )
    )
  )

Read many

import io.github.jahrim.hexarc.persistence.mongodb.language.queries.ReadQuery
import com.mongodb.client.model.{Filters, Projections, Updates, Aggregates}
import org.bson.{BsonDocument, BsonString}

type QueryResult = userCollection.ReadQueryResult
val queryResult: Try[QueryResult] = 
  userCollection.read(
    ReadQuery(
      filter = Filters.eq("username", "Marco"),
      projection = Projections.include("email")
    )
  )
  
println(queryResult)   // Success(Seq({ "email": "marco@hexarc.com" }))

Read with Aggregation Pipeline

import io.github.jahrim.hexarc.persistence.mongodb.language.queries.ReadQuery
import com.mongodb.client.model.{Filters, Projections, Updates, Aggregates}
import org.bson.{BsonDocument, BsonString}

type QueryResult = userCollection.ReadQueryResult
val queryResult: Try[QueryResult] =
  userCollection.read(
    ReadQuery.pipeline(
      Aggregates.`match`(Filters.eq("username", "Marco")),
      Aggregates.project(Projections.include("username")),
      Aggregates.limit(1)
    )
  )

Update many

import io.github.jahrim.hexarc.persistence.mongodb.language.queries.UpdateQuery
import com.mongodb.client.model.{Filters, Projections, Updates, Aggregates}
import org.bson.{BsonDocument, BsonString}

type QueryResult = userCollection.UpdateQueryResult
val queryResult: Try[QueryResult] = 
  userCollection.update(
    UpdateQuery(
      filter = Filters.eq("username", "Marco"),
      update = Updates.set("email", BsonString("marco2@hexarc.com"))
    )
  )

Delete many

import io.github.jahrim.hexarc.persistence.mongodb.language.queries.DeleteQuery
import com.mongodb.client.model.{Filters, Projections, Updates, Aggregates}
import org.bson.{BsonDocument, BsonString}

type QueryResult = userCollection.DeleteQueryResult
val queryResult: Try[QueryResult] =
  userCollection.delete(
    DeleteQuery(
      filter = Filters.eq("username", "Marco")
    )
  )

Table of Contents