Bancos de dados e coleções

Pré-requisitos

Você deve incluir as seguintes declarações de importação em seu programa para executar os exemplos de código neste guia:

import org.mongodb.scala._
import org.mongodb.scala.model.Filters._

Conecte-se a um MongoDB deployment

Primeiro, conecte-se a uma implementação do MongoDB em execução.

O código a seguir se conecta a uma MongoDB deployment standalone em execução em localhost na porta 27017:

val mongoClient = MongoClient()

Para saber mais sobre como se conectar a sistemas do MongoDB, consulte o tutorial Conectar ao MongoDB .

Acessar um banco de dados

Após conectar uma instância do MongoClient a um MongoDB deployment, utilize o método `getDatabase() para acessar um banco de dados.

Passe o nome do banco de dados como um parâmetro para o método getDatabase() . Se um banco de dados não existir, o MongoDB o criará quando você inserir quaisquer dados no banco de dados.

O exemplo a seguir acessa o banco de dados do test :

val database: MongoDatabase = mongoClient.getDatabase("test")

Acessar uma coleção

Após criar uma instância do MongoDatabase , utilize o método getCollection() para acessar uma coleção de dentro deste banco de dados.

Passe o nome da coleção como um parâmetro para o método getCollection() .

Utilizando a instância database criada na seção anterior, o seguinte código acessa a coleção denominada myTestCollection:

val coll: MongoCollection[Document] = database.getCollection("myTestCollection")

Se uma coleção com esse nome não existir, o MongoDB a criará quando você inserir os dados pela primeira vez nessa coleção.

Você também pode criar diretamente uma coleção com várias opções, como definir o tamanho máximo ou criar regras de validação de documentação.

Criar uma coleção

O driver fornece o método createCollection() para criar uma coleção diretamente. Ao criar uma collection, você pode especificar várias opções de collection, como um tamanho máximo ou regras de validação de documentação, com a classe CreateCollectionOptions .

Se você não estiver especificando nenhuma opção, não precisará criar a coleção diretamente, pois o MongoDB cria automaticamente novas coleções quando você insere os dados pela primeira vez.

database.createCollection("cappedCollection", CreateCollectionOptions().capped(true).sizeInBytes(0x100000))
        .printResults()

ValidationOptions collOptions = ValidationOptions().validator(
        Filters.or(Filters.exists("email"), Filters.exists("phone")))
database.createCollection("contacts", CreateCollectionOptions().validationOptions(collOptions))
        .printResults()

Obter uma lista de coleções

Você pode obter uma lista das coleções em um banco de dados utilizando o método MongoDatabase.listCollectionNames() :

database.listCollectionNames().printResults()

Solte uma coleção

Você pode descartar uma coleção e excluir todos os dados na coleção usando o método MongoCollection.drop() :

val collection: MongoCollection[Document] = database.getCollection("contacts")
collection.drop().printResults()

Imutabilidade

MongoDatabase e MongoCollection instâncias são imutáveis. Para criar novas instâncias a partir de instâncias existentes que tenham propriedades diferentes, como diferentes read concerns, read preferences e write concerns, as classes MongoDatabase e MongoCollection fornecem os seguintes métodos:

• MongoDatabase.withReadConcern()

• MongoDatabase.withReadPreference()

• MongoDatabase.withWriteConcern()

• MongoCollection.withReadConcern()

• MongoCollection.withReadPreference()

• MongoCollection.withWriteConcern()

Para saber mais, consulte os tutoriais Operações de leitura e Operações de gravação .

CodecRegistry

Uma sobrecarga do método getCollection() permite especificar uma classe diferente para representar documentos BSON. Por exemplo, talvez você queira usar a classe BsonDocument rigorosa e com segurança de tipo para modelar seus documentos ao executar operações CRUD:

import org.mongodb.scala.bson._
val collection: MongoCollection[BsonDocument] = database.getCollection[BsonDocument]("mycoll")
// insert a document
val document = BsonDocument("{x: 1}")
collection.insertOne(document).printResults()
document.append("x", BsonInt32(2)).append("y", BsonInt32(3))
// replace a document
collection.replaceOne(Filters.equal("_id", document.get("_id")), document)
          .printResults()
// find documents
collection.find().printResults()

Há dois requisitos que qualquer classe deve atender para ser usada dessa forma:

• Codec a instância da classe deve ser registrada em CodecRegistry para MongoCollection.

• Codec A instância deve ser aquela que codifica e decodifica um documento BSON completo, e não apenas, por exemplo, um único valor BSON como um Int32.

Por padrão, um MongoCollection é configurado com instâncias do Codec para quatro classes:

• Document (Scala BsonDocument wrapper)

• BsonDocument

• Document (Classe Document do driver Java com digitação livre)

• BasicDBObject

Os aplicativos são gratuitos para registrar implementações Codec para outras classes personalizando o CodecRegistry. Novas instâncias CodecRegistry são configuráveis nos seguintes níveis:

• Em um MongoClient dentro MongoClientSettings

• Em um MongoDatabase dentro de seu método withCodecRegistry

• Em um MongoCollection dentro de seu método withCodecRegistry

Considere o caso de instâncias de codificação e decodificação da classe UUID . O driver por padrão codifica instâncias de UUID usando uma ordenação de bytes que não é compatível com outros drivers do MongoDB, e alterar o padrão seria perigoso.

É possível que novos aplicativos que exigem interoperabilidade entre vários drivers possam alterar esse padrão, e eles podem fazer isso especificando um CodecRegistry

// replaces the default UuidCodec with one that uses the new standard UUID representation
import org.bson.UuidRepresentation
import org.bson.codecs.UuidCodec
import org.bson.codecs.configuration.CodecRegistries
val codecRegistry = CodecRegistries.fromRegistries(
  CodecRegistries.fromCodecs(new UuidCodec(UuidRepresentation.STANDARD)),
  MongoClient.DEFAULT_CODEC_REGISTRY)
// globally
val settings = MongoClientSettings.builder()
                .codecRegistry(codecRegistry).build()
val client = MongoClient(settings)
// or at the database level
val database = client.getDatabase("mydb")
                     .withCodecRegistry(codecRegistry)
// or at the collection level
val collection = database.getCollection("mycoll")
                         .withCodecRegistry(codecRegistry)