How to save the outcome of collection.find into Array - mongodb

Question

object ConnHelper extends Serializable{
lazy val jedis = new Jedis("localhost")
lazy val mongoClient = MongoClient("mongodb://localhost:27017/recommender")
}
val ratingCollection = ConnHelper.mongoClient.getDatabase(mongoConfig.db).getCollection(MONGODB_RATING_COLLECTION)
val Existratings: Observable[Option[BsonValue]] = ratingCollection
.find(equal("userId",1234))
.map{
item => item.get("productId")
}
The documents are like these
{
"id":****,
"userId":4567,
"productId":12345,
"score":5.0
}
I use Scala and Mongo-Scala-driver 2.9.0 to connect MongoDB and find documents where the "userId" field equal 1234, then I want save the value of "productId" of the documents into Array, but the returned value is observable type.
Could anyone tell how to save the query outcome into Array? I would appreciate it very much.

Answer 1

Please try a method which uses a Promise/Future structure to find the sequence of documents that match the search criteria. For example:
import org.mongodb.scala.bson._
def find (search_key: String, search_value: String, collection_name: String): Seq[Document] = {
// The application will need to wait for the find operation thread to complete
// in order to process the returned value.
log.debug(s"Starting database find_all operation thread")
// Set up new client connection, database, and collection
val _client: MongoClient = MongoClient(config_client)
val _database: MongoDatabase = _client.getDatabase(config_database)
val collection: MongoCollection[Document] = _database.getCollection(collection_name)
// Set up result sequence
var result_seq : Seq[Document] = Seq.empty
// Set up Promise container to wait for the database operation to complete
val promise = Promise[Boolean]
// Start insert operation thread; once the thread has finished, read resulting documents.
collection.find(equal(search_key, search_value)).collect().subscribe((results: Seq[Document]) => {
log.trace(s"Found operation thread completed")
// Append found documents to the results
result_seq = result_seq ++ results
log.trace(s" Result sequence: $result_seq")
promise.success(true) // set Promise container
_client.close // close client connection to avoid memory leaks
})
val future = promise.future // Promise completion result
Await.result(future, Duration.Inf) // wait for the promise completion result
// Return document sequence
result_seq
}
Then you can iterate through the document sequence and pull the products into a List (better than Array).
def read : List[String] = {
val document_seq = Database.find("userID","1234",collection)
// Set up an empty return map
val return_map : mutable.Map[String, String] = mutable.Map.empty
// Translate data from each document into Product object
document_seq.foreach(_document => {
return_map.put(
_document("id").asString.getValue,
_document("productId").asString.getValue
)
})
// Convert values to list map and return
return_map.values.toList
}

Answer 2

The Mongo Scala Driver uses the Observable model which is composed by three parts.
You need to subscribe an observer to the observable. Take a look to the examples.
The fastest solution is to coplete with a toFuture call:
val Existratings =
ratingCollection
.find(equal("userId",1234))
.map{
item => item.get("productId")
}.toFuture()
That will return a Sep of BsonValues with the resultset

Answer 3

this maybe:
val productIds = ratingCollection
.find(equal("userId",1234))
.map { _.get("productId") }
.toArray

Answer 4

The most direct solution to get an Array is to fold directly in one:
ratingCollection
.find(???)
.map { ??? }
.foldLeft(Array.empty[Item]) { _ :+ _ }
.head() //in order to get a Future[Array[Item]]
.onComplete {
case Success(values: Array[Item]) => //capture the array
case Failure(exception) => //fail logic
}
It's probably best to work with the Future rather build your own Observer logic for subscription.