Use construtores com classes de dados

Nesta página

Visão geral

Adicionar extensões Kotlin ao seu projeto
Exemplos de construtores
Dados de amostra
Filtros
Indexes
Projeções
Tipos
Updates
Agregados
Documentação da API

Visão geral

Neste guia, você pode aprender como usar suas propriedades de classe de dados diretamente com as classes de construtor disponíveis no driver Kotlin .

O driver Kotlin implementa extensões que permitem a você referenciar suas propriedades de classe de dados ao utilizar métodos de construtor em vez de utilizar nomes de campo de string. Você pode estruturar seu código dessa forma para torná-lo mais seguro para o tipo e melhorar a interoperabilidade do Kotlin dos seus aplicativos.

A biblioteca de extensões também permite que você construa queries, atualize documentos e escreva outras declarações usando a notação infix. Para saber mais sobre esta notação, consulte Notação Infix na documentação de referência do Kotlin .

Observação

Esta página fornece um número limitado de exemplos de código para demonstrar essa funcionalidade. Para ver exemplos de todas as classes de construtores, consulte os guias deconstrutores .

Adicionar extensões Kotlin ao seu projeto

Para implementar esta funcionalidade, você deve adicionar a dependência do mongodb-driver-kotlin-extensions à sua lista de dependências.

Selecione a partir das seguintes abas para ver como adicionar a dependência de extensão ao seu projeto usando os gerenciadores de pacote Gradle e Maven:

Se você estiver usando o Gradle para gerenciar suas dependências, adicione o seguinte à sua build.gradle.kts lista de dependências do :

build.gradle.kts

implementation("org.mongodb:mongodb-driver-kotlin-extensions:5.3.0")

Se você estiver usando o Maven para gerenciar suas dependências, adicione o seguinte à sua pom.xml lista de dependências do :

pom.xml

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-kotlin-extensions</artifactId>
    <version>5.3.0</version>
</dependency>

Depois de instalar a dependência de extensões, você pode usar os métodos de extensão importando classes e métodos do com.mongodb.kotlin.client.model caminho. É possível misturar o uso desses métodos e dos métodos de construtor padrão no mesmo aplicação, conforme mostrado no exemplo de Agregados neste guia.

Exemplos de construtores

Esta seção contém exemplos que demonstram como usar as propriedades da classe de dados diretamente com os métodos da classe de construtor a partir do pacote de extensões .

Dica

Anotações da classe de dados

Quando você o construtor de extensões de classe de dados de métodos de classe, os métodos respeitam suas anotações de classe de dados bson-kotlin dos bson-kotlinx pacotes e . Para saber mais sobre anotações, consulte a seção Especificar conversão de componente usando anotações do guia Formato de dados do documento: classes de dados e a seção Anote classes de dados no guia Serialização de Kotlin .

Dados de amostra

Os exemplos nesta seção usam documentos na coleção students que descrevem alunos em uma escola. Os documentos na coleção students são modelados pela seguinte classe de dados Kotlin :

data class Student(
    val name: String,
    val teachers: List<String>,
    val gradeAverage: Double
)

Filtros

Você pode usar ajudantes da Filters classe de construtores para consultar propriedades da classe de dados. Para saber mais sobre essa classe, consulte o guia Construtores de filtros.

O código abaixo mostra maneiras diferentes de usar os métodos de extensão Filters para executar queries na classe de dados Student:

import com.mongodb.kotlin.client.model.Filters.eq
import com.mongodb.kotlin.client.model.Filters.all

val student = Student(
    "Sandra Nook",
    listOf("Alvarez", "Gruber"),
    85.7
)
// Equivalent equality queries
Student::name.eq(student.name)
eq(Student::name, student.name)
Student::name eq student.name // Infix notation
// Equivalent array queries
all(Student::teachers, student.teachers)
Student::teachers.all(student.teachers)
Student::teachers all student.teachers // Infix notation

Indexes

Você pode usar ajudantes da Indexes classe de construtores para criar índices nas propriedades da classe de dados. Para saber mais sobre essa classe, consulte o guia Indexes Builders.

O seguinte código mostra maneiras diferentes de usar os métodos de extensão Indexes para criar índices na classe de dados Student :

import com.mongodb.kotlin.client.model.Indexes.ascending
import com.mongodb.kotlin.client.model.Indexes.descending

val ascendingIdx = Indexes.ascending(Student::name)
val descendingIdx = Indexes.descending(Student::teachers)
val ascIdxName = collection.createIndex(ascendingIdx)
val descIdxName = collection.createIndex(descendingIdx)

Projeções

Você pode utilizar ajudantes da Projections classe de construtores do para criar projeções para propriedades de classe de dados. Para saber mais sobre essa classe, consulte o guia Construtores de projeções.

O seguinte código mostra como usar os métodos de extensão Projections para criar uma projeção na classe de dados Student:

import com.mongodb.kotlin.client.model.Projections.excludeId
import com.mongodb.kotlin.client.model.Projections.fields
import com.mongodb.kotlin.client.model.Projections.include

val combinedProj = fields(
    include(Student::name, Student::gradeAverage),
    excludeId()
)
collection.find().projection(combinedProj)

Tipos

Você pode usar ajudantes da Sorts classe de construtores para classificar as propriedades da sua classe de dados. Para saber mais sobre essa classe, consulte o guia Sorts Builders.

O código a seguir mostra como usar os métodos de extensão Sorts para criar classificações diferentes na classe de dados Student :

import com.mongodb.client.model.Sorts.orderBy
import com.mongodb.kotlin.client.model.Sorts

val sort = orderBy(
    Sorts.descending(Student::gradeAverage),
    Sorts.ascending(Student::name)
)
collection.find().sort(sort)

Updates

Você pode usar ajudantes da Updates classe de construtores para executar atualizações usando suas propriedades de classe de dados. Para saber mais sobre essa classe, consulte o guia Updates Builders.

O código a seguir mostra como usar os métodos de extensão Sorts para criar classificações diferentes na classe de dados Student :

import com.mongodb.kotlin.client.model.Filters.gte
import com.mongodb.kotlin.client.model.Updates.addToSet
import com.mongodb.kotlin.client.model.Updates.combine
import com.mongodb.kotlin.client.model.Updates.max

val filter = Student::gradeAverage gte 85.0
val update = combine(
    addToSet(Student::teachers, "Soto"),
    Student::gradeAverage.max(90.0)
)
collection.updateMany(filter, update)

Agregados

Você pode utilizar os auxiliares Aggregates das Accumulators classes de construtores e para executar agregações utilizando suas propriedades de classe de dados. Para saber mais sobre essas classes, consulte o guia Aggregates Builders.

O código a seguir mostra como usar os métodos de extensão Accumulators e os métodos assistente de Aggregates para executar uma agregação na classe de dados Student :

import com.mongodb.client.model.Aggregates.group
import com.mongodb.client.model.Aggregates.limit
import com.mongodb.client.model.Aggregates.sort
import com.mongodb.kotlin.client.model.Accumulators.avg

// Data class to store aggregation result
data class Summary ( val average: Double )
val pipeline = listOf(
    // Sorts grades from high to low
    sort(Sorts.descending(Student::gradeAverage)),
    // Selects the top 3 students
    limit(3),
    // Calculates the average of their grades and stores value in a Summary instance
    group(null, avg(Summary::average, "\$${Student::gradeAverage.name}"))
)
val result = collection.aggregate<Summary>(pipeline)

Documentação da API

Extensões do driver Kotlin

Voltar

Update

Agregação