NoSQL: Bancos de dados orientados à Document

História

Introdução

Estruturação de dados: Document => Tupla/Registro.

• Database é composta de collections.
• Collection é composta de documentos. Analoga a Table.
• Document é a menor unidade dentro do banco. É o que identifica o registro, é a referência de uma tupla.
Dados e documentos devem ser autocontidos e auto descritivos.

• Serialização codificada em binário de documentos semelhantes a JSON
• Contém extensões que permitem a representação de tipos de dados que não fazem parte da espeficação JSON
JSON lida apenas com dados primitivos.
BSON lida com dados além dos primitivos, como ObjectID, Date, etc.

Usabilidade

MongoDB

• Armazena os dados em BSON (Binary JSON)
Que são pares de chaves e valores.
• Permite que dentro de uma collection pode-se ter documentos de estruturas diferentes
Não que isso seja uma boa prática.
• Suporte a indices
Consultas mais complexas ou para garantir algumas integridades.
• Auto-Sharding
Nativamente feito para escalar horizontalmente. Mas permiti escalar verticalmente com réplica de leitura.
• Map-Reduce
Ferramenta poderosa de consulta e agregação para grandes volumes de dados.
• GridFS
Armazenamento de arquivos.
• Rica linguagem de consulta
Permiti fazer quase tudo dentro do banco de dados.

Quando usar

• Grande volume de dados com alta performance
• Dados não necessariamente estruturados

Quando não usar

• Necessidade de relacionamentos/joins
• Propriedades ACID e transações são importantes
• Curiosidade: Diversas entidades de pagamento não homologam
Os dados financeiros dos clientes precisam estar em um banco de dados relacional tradicional.

Schema Design

Relationships: Como os dados vão se relacionar entre si? Há duas formas de modelar

• Embedding
Boa prática: SIM
Documentos autocontidos, onde todas as informações necessárias vão estar dentro dele, sem a necessidade de fazer referência para outros documents ou collectins.


Prós

• Consulta informações em uma única query
• Atualiza o registro em uma única operação

Contras

• Limite 16MB por documento
• Reference
Boa prática: NÃO
Documents com dependência de outros documentos ou collections.
Não existe o conceito de FK (Forein Key), então não há uma constraint para garantir esses relacionamentos.
As references serão realizadas através de atributos dentro dos documents ou collectins.
*Dados não devem depender de outros dados, pode ocasionar redundâncias.


Prós

• Documentos pequenos (Não armazena as references)
• Não duplica informações
• Usado quando os dados não são acessados em todas as consultas
Para cada subdocumento é realizado uma nova query, a responsabilidade dos joins do banco é transferida para a app, aí entra toda uma questão de rede, de latência, e isso pode comprometer a performance.

Contras

• Perde Atomicidade
• Duas ou mais queries ou utilização do $lookup
$lookup é o comando para executar queries com referências.

OBS: Não existem problemas em os dados não estarem normalizados, tudo depende da necessidade de cada projeto.

Scheme design: Embedding vs Reference

Boas Práticas

• Evitar documentos muito grandes.
• Nomes significativos e curtos
Porque documentos são compostos não somente com valores, mas também com os seus schemes.
Visando a questão de espaço de armazenamento e clareza de significados as informações.
• Analise as queries usando explain()
MongoDB Compass mostra gráficamente uma análise das queries.
MongoDB tem esse comando explain() para dar no final da querie, que mostra uma análise.
• Atualize apenas os campos alterados
Comando update recebe JSON por completo, problema disso é que vai realizar toda a substituição binária da informação.
Recomendado, atualizar somente os campos necessários e não o JSON por completo.
• Evite negações em queries
MongoDB não consegue indexar condições e valores negativos, então nestes casos ele faz um escaneamento completo da collection.
• Listas/Arrays dentro de documentos não podem crescer sem limite
Porque podem gerar problemas de performance.

One-to-one

                                {
                                    "_id": ObjectId("5c8f8f8f8f8f8f8f8f8f8f8"),
                                    "name": "Dio",
                                    "street": "Rua das Flores",
                                    "number": "123"
                                }
                            

One-to-few

                                {
                                    "_id": ObjectId("5c8f8f8f8f8f8f8f8f8f8f8"),
                                    "name": "Dio",
                                    "addresses": [
                                        {"street": "Rua das Flores", "number": "123"}, 
                                        {"street": "Av das Perolas", "number": "100"}
                                    ]
                                }
                            

One-to-many e Many-to-many

                                {
                                    "_id": ObjectId("5c8f8f8f8f8f8f8f8f8f8f8"),
                                    "name": "Dio",
                                    "addresses": [ ObjectId('123'), ObjectId('456') ]
                                }
                                // addresses
                                {
                                    "_id": ObjectId("123"),
                                    "street": "Rua das Flores",
                                    "number": "123"
                                }
                                {
                                    "_id": ObjectId("456"),
                                    "street": "Av das Perolas",
                                    "number": "100"
                                }  
                            

Patterns de acordo com casos de uso para escolha de Schemes design

Scheme design: Patterns according to use cases

Conceitos na prática

MongoDB - Client

MongoDB - Cloud

Comando nativo para conectar-se ao MongoDB

                                mongo --host 127.0.0.1:27017 -p dio -u dio
                            

                                // LISTA databases
                                    show databases
                                    show db_name

                                // SELECIONA se existir
                                // CRIA se não existir
                                    use db_name
                            

Operações de manipulação de dados

Criar collections

• Explicitamente
Comando createCollection(), permite passar alguns validadores, por exemplo, tamanho máximo do documento ou da collection, entre inumeros outros.


                                        db.createCollection("name_collection");
                                        db.createCollection("name_collection", {capped: true, max: 2, size: 2});
                                    

• Implicitamente
Menção ao nome da collection, se não existir, mongodb cria automaticamente. Sem validadores.

                                        db.name_collection.insertOne( {'name': 'teste 1'} );
                                    

Consultar collactions

• Todas as collactions

                                        show collections;
                                    

Consultar documentos

• Todos os documentos da collaction especificada
É necessário passar o parâmetro (1º parametro) de macth (query), que é um objeto contendo pares de key e value usados para realização dos filtros.
Quando a query for passada vazia, retorna todos os documentos.

                                        db.name_collection.find({});
                                    

• Consultar documentos com condição e limite
Filtra todos os documentos que tenham a idade igual a 40 anos.
Limita o número de documentos retornados em 1 (Retorna o primeiro que encontrar).

                                        db.name_collection.find({'age': 40}).limit(1);
                                    

• Consultar documentos com mais de uma condição
Filtra todos os documentos que tenham a idade igual a 40 anos e que sejam do genero feminino.

                                        db.name_collection.find({'gender': 'woman','age': 40});
                                    

• Consulta documentos com operador in
O operador in recebe uma lista e é usado para filtrar por um range.
Filtra todos os documentos que tenham a idade igual a 40 ou 41 ou 42 anos.

                                        db.name_collection.find( {'age': {$in: [40, 41, 42]} } );
                                    

• Consulta documentos com operador or
O operador or recebe uma lista.
Filtra todos os documentos que sejam do sexo feminino OU que tenham a idade de 41 anos.

                                        db.name_collection.find( { $in: [ {'gender': 'woman'}, {'age': 41}] } );
                                    

• Consulta documentos com operador lt e lte
lt - menor que.
lte - menor ou igual.


                                        db.name_collection.find( {'age': {$lt: 45} } );

                                        db.name_collection.find( {'age': {$lte: 45} } );
                                    

Inserir documentos em collactions

MongoDB gera o ID e o indice do ID de forma automática.
• Inserir um documento
Retorna o ID do objeto criado.

                                        db.name_collection.insertOne( {'name': 'teste 1'} );
                                    

• Inserir lista de documentos
Recebe um array de documentos, retorna um objeto result (chamado de BulkWriteResult).

                                        db.name_collection.insert( 
                                            [
                                                {'name': 'teste 1'}, 
                                                {'name': 'teste 2'},
                                                {'name': 'teste 3'}
                                            ] 
                                        );
                                    

Atualização

• Comando save()
Recebe documento ou ID, e realiza a atualização se existir ou a criação se não existir.
Realiza atualização do documento por completo.

                                        db.name_collection.save( {'name': 'teste 1'} );
                                    

• Comando update()
Parametros:
• 1º - objeto com os campos para filtrar, condição (query)
• 2º - objeto com os campos a serem atualizados
• 3º - objeto com as configurações (há inumeras opções)
multi = true - atualiza todos os documentos que atendem a condição.
Obs: A partir da versão 3.2, está disponivel o comando updateMany(), no qual não é necessário passar as configurações.
Atualização somente os atributos especificados (2º parâmetro).
Se atributo existir, atualiza, caso contrário cria novo atributo.

                                        db.name_collection.update(
                                            {'name': 'teste 1'},
                                            {'$set': {'age': 40} }
                                        );

                                        db.name_collection.update(
                                            {'age': 40},
                                            {'$set': {'age': 45} },
                                            { multi = true }
                                        );
                                    

• Comando updateMany()
Disponível a partir da versão 3.2, no qual não é necessário passar as configurações.
Parametros:
• 1º - objeto com os campos para filtrar, condição (query)
• 2º - objeto com os campos a serem atualizados

                                        db.name_collection.updateMany(
                                            {'age': 45},
                                            {'$set': {'age': 50} } 
                                        );
                                    

Excluir documentos em collactions

• deleteOne()
Exclui somente um documento. Se usado em uma query que retorna mais de um documento, exclui o primeiro.


                                        // Return um count de 1
                                        db.name_collection.deleteOne( {'age': 50} );  
                                    

• deleteMany()
Exclui todos os documentos.


                                        // Return um count de N (quantidade de documentos excluidos)
                                        db.name_collection.deleteMany( {'age': 50} );  
                                    

Performance e indices

Fatores Importantes

• Escalonamento
• Disco
• Rede
• Indices
Mesmo conceito dos bancos relacionais. Fornecer uma direção de onde estão os dados para acesso mais rápido.
A única diferença é que nos bancos relacionais o objetivo é prevenir uma table scan, e no MongoDB é prevenir o scan collection.

Exemplo Prático (Robo 3T)
1. Criar uma collection
2. Criar um script para inserir dados em massa

                                            // Script em JavaScript para inserir dez mildocumentos
                                                for(var i=0, i < 10000; i++){
                                                    db.name_collection.insert({name: 'teste ' + i, age: i});
                                                }
                                            // Consultar a quantidade de documentos inseridos
                                                db.getCollection('teste').count();
                                            // Listar todos os documentos 
                                                db.getCollection('teste').find({});
                                        

3. Realizar query com o comando explain()
explain() serve para analisar e retornar algumas informações sobre o processamento da query.


                                            // Consulta pelo ID (Não realiza um scan collection)
                                            // Vai direto no ID através do indice, 1 documento examinado
                                                db.getCollection('teste').find({_id: ObjectId('5c8f8f8f8f8f8f8f8f8f8f8')}).explain(true);

                                            // Consulta (Realiza um scan collection), 10000 documentos examinados
                                                db.getCollection('teste').find({name: 'teste0'}).explain(true);
                                        

4. Criar indice (recebe dois parâmetros)
4.1. Campo e tipo de indice.
4.2. Nome do indice.

                                            // Indexar campo "name" de forma ordenada
                                                db.getCollection('teste').createIndex({name: 1}, {'name':'idx_name'});
                                        

Agregações

Agregação de propósito único

Não permitem customizações.
• count
Retorna a quantidade de documentos.

                                        db.getCollection('teste').count({});
                                    

• distinct
Retorna todos os possíveis valores de forma não duplicada de determinado campo.

                                        db.getCollection('teste').distinct('name');
                                    

Agregação de pipeline

Pipeline is a technique for implementing instruction-level parallelism within a single processor. A segmentação de instruções (em inglês, pipeline) é uma técnica de hardware que permite que a CPU realize a busca de uma ou mais instruções além da próxima a ser executada.
Permitem customizações. Recebem um array como parâmetro. As pipelines mais básicas fornecem "filtros" e "operadores".
Permite passar um número infinito de processamento.
Filtros são as condições que vão dar match para descobrir quais dados serão processados.
Operadores são as funções que vão manipular os dados e dar input para as próximas etapas.
• $group
Agrupar dados conforme um campo, e realizar diversas operações matemáticas, por exemplo: count, average, min, max, etc.

                                        db.getCollection('teste').aggregate([
                                            {
                                                $group: { _id: '$name', count: {$sum: 1} }
                                            }
                                        ]);
                                    

• $addFields
Permite adicionar um novo campo para o resultado, sem alterar a collection de origem.

                                         db.getCollection('teste').aggregate([
                                            {
                                                $addFields: { 'new_field': {$sum: 1} }
                                            }
                                    

Funções

• $sum

                                        db.getCollection('teste').aggregate([
                                            {
                                                $group: { _id: '$name', count: {$sum: 1}, sum: {$sum: '$age'} }
                                            }
                                        ]);
                                    

• $avg

                                        db.getCollection('teste').aggregate([
                                            {
                                                $group: { _id: '$name', count: {$sum: 1}, average: {$avg: '$age'} }
                                            }
                                        ]);
                                    

• $max

                                        db.getCollection('teste').aggregate([
                                            {
                                                $group: { _id: '$name', count: {$sum: 1}, max: {$max: '$age'} }
                                            }
                                        ]);
                                    

• $min

                                        db.getCollection('teste').aggregate([
                                            {
                                                $group: { _id: '$name', count: {$sum: 1}, min: {$min: '$age'} }
                                            }
                                        ]);
                                    

Operadores Lógicos

Função match responsável por aplicar os filtros. Recebem um array como parametro.
• $and

                                        db.getCollection('teste').aggregate([
                                            {
                                                $match: { $and: [ {gender: 'woman'}, {age: {$gt: 20}} ] }
                                            }
                                        ]);
                                    

• $or

                                        db.getCollection('teste').aggregate([
                                            {
                                                $match: { $or: [ {gender: 'woman'}, {age: {$gt: 20}} ] }
                                            }
                                        ]);
                                    

• $not
• $nor

Operadores de Comparação

• $gt Maior que
• $lt Menor que
• $nte Diferente de
• $eq Igual
• $lte Menor ou igual
• $gte Maior ou igual

• mongodb.com
• mongodb.com/cloud
• Cliente Robo 3T
• Cliente Compass
• Mongoose.js - Elegant mongodb object modeling for Node.js