Mongo DB – Primeiros passos

Mongo DB – Primeiros passos

Caros leitores, hoje vamos tratar de um assunto que anda muito na moda ultimamente.

Os bancos de dados conhecidos como não relacionais, ou NoSQL.

Longe das brigas com relação à qual o termo correto deveríamos usar para designar esse tipo de tecnologia, o que basicamente se entende como NoSQL são: banco de dados que tem estruturas mais livres do que os bancos relacionais tradicionais e que usam relacionamentos entre tabelas.
O NoSQL tende a ser um agregador de documentos que não precisam seguir um esquema (schema) pré-estabelecido.

E qual a vantagem em utilizar um banco NoSQL?

É bem verdade que nem toda a aplicação necessita trocar seu banco de dados relacional por alguma solução NoSQL sem necessidade, mas algumas vantagens são logo percebidas:

  1. Bancos NoSQL suportam tipos de dados com estruturas não rígidas, que permitem que mudanças na estrutura sejam feitas sem que seja necessário a manutenção de toda a tabela do banco para suportá-las.
  2. A performance de bancos NoSQL com relação aos relacionais, é considerável. Como o NoSQL usa uma estrutura mais simples, que geralmente não se prende a tabelas que são amarradas à outras tabelas, a busca por dados se torna muito dinâmica.
  3. Baixo custo de manutenção, com relação à dados de SQL tradicionais. Geralmente, as manutenções de bancos relacionais são custosas e precisam ser feitas por pessoas altamente capacitadas para tal.

 

O NoSQL MongoDB

O MongoDB é um dos bancos de dados não relacionais mais utilizados atualmente por ser robusto, elástico, opensource e de fácil manutenção.

Vamos entender um pouco sobre como o MongoDB funciona?

Estruturado para ser não estruturado

Como mencionado, o MongoDB e os bancos NoSQL em geral, foram criados para aceitar estruturas de dados menos rígidas do que um banco relacional como um MySQL por exemplo. Mas o que isso significa na prática?

Vamos dar um exemplo:

Digamos que você esteja criando um banco de dados relacional para armazenar dados de um cliente e os dados de uma loja, algo super comum em qualquer sistema.

Primeiramente você teria que fazer a modelagem dos dados, o que faria a separação das entidades e seus respectivos métodos.

Isso lhe daria a princípio, duas entidades: a do cliente e a da loja, além dos respectivos métodos, nesse caso, para exemplificar, vou usar a entidade funcionário, que vai ser a pessoa que vai vender para este cliente.

Então teríamos algo como abaixo:

 

Veja que eu separei os métodos que cada entidade tem, com suas características como nome, sexo, e-mail etc.

Todos esses campos tem os tipos específicos, como nome e e-mail que são do tipo “string” e o telefone e o ID que são do tipo “int”, isso é o “schema” do banco de dados, ou seja, sua estrutura.

Em ambos os casos usamos um ID como chave para se referenciar à um item específico da tabela, após isso, usaremos o campo de como um link para que outra tabela consulte os dados do cliente ou do vendedor.

O problema é que a tendência natural de qualquer sistema, é aumentar e expandir a ideia relacional, para tornar os dados mais confiáveis e evitar repetições e dados sobrepostos, o que leva naturalmente às especificidades de cada entidade, que poderia elevar facilmente a complexidade para algo assim:

 

 

Os itens da tabela Pessoa física e da tabela Pessoa Jurídica, alimentam a tabela Pessoa que por sua vez alimenta a tabela cliente e que também recebe dados da tabela serviço.

Agora imagine, quanto tempo um sistema precisa para varrer dados que estão espalhados em diversas tabelas, amarrados por campos uns aos outros?

No MongoDB, tudo isso é simplesmente ignorado, pois aquele “schema” onde é declarado qual tipo de dado teríamos ali, simplesmente não existe.

É possível criar documentos dentro do MongoDB com dados de campos totalmente diferentes e ele ainda assim aceitaria:

{"curso": "MongoDB para DBAs", "duracao": "40h"}
{"aluno": "Linus Torvalds", curso: "Python para SysAdmins"}

Quando você não têm estruturas, você é mais livre e portanto, alterações na base de dados não precisam destruir o que existe e podem ser facilmente implementadas.

Isso traz poder ao NoSQL de ser muito mais ágil na busca de dados na base e nas alterações necessárias.

O básico do MongoDB

Certo, entendi porque o MongoDB pode me ajudar, mas… como posso usar ele na prática?

Preparei um compilado de comandos interessantes para você usar na primeira vez e ir se familiarizando com o MongoDB.

Arquitetura do MongoDB:

  1. Dados são escritos sob a forma “chave:valor”
  2. Conjuntos de dados chave-valor são “Documentos”
  3. Conjuntos de Documentos formam as “Collections”
  4. Conjuntos de Collections formam as “Databases”

Para se conectar ao mongo, basta dar o comando:

mongo -u -p

Após conectar-se, vamos listar as databases e para isso devemos executar:

> show dbs;
admin 0.000GB
config 0.000GB
local 0.000GB
my_database 0.004GB

E se quisermos saber o que temos dentro das databases, algo como um “show tables”?

Podemos usar o comando abaixo

> use my_database;
> show collections;
users
posts
>

E quando precisamos saber quantos documentos temos dentro de uma collection?

Contar documentos em uma Collection

> use my_database;
> db.users.count()
20234
>

CRUD – Create Read Update Delete

Conhecido como CRUD, estes são comandos básicos que todo sistema de banco de dados deve fazer: poder criar, ler, alterar e apagar collections, databases e documentos.

Create (Insert)

Para inserir documentos em uma collection, basta usar o insert():

> use dexter
> db.funcionarios.insert({"nome":"marquito"})
WriteResult({ "nInserted" : 1 })

Importante: para criar os bancos de dados, precisamos primeiro criar as collections e inserir documentos dentro delas.

Read (Find)

Encontrar o primeiro documento de uma Collection

> db.users.findOne()
{
"_id": ObjectId("5ce45d7606444f199acfba1e"),
"name": {given: "Alex", family: "Smith"},
"email": "email@example.com"
"age": 27
}
>

Encontrar um documento pelo ID

> db.users.findOne({_id: ObjectId("5ce45d7606444f199acfba1e")})
{
"_id": ObjectId("5ce45d7606444f199acfba1e"),
"name": {given: "Alex", family: "Smith"},
"email": "email@example.com",
"age": 27
}
>

Limitar a quantidade de resultados


> db.users.find().limit(10)
…
>

Encontre a quantidade de usuários pelo campo

> db.users.find({"name.family": "Smith"}).count()
1
>

Procurar Documentos pelo campo

// Todos os filmes do ano de 1993:

> db.filmes.find({"ano":"1993"})

Usando maior ou menor que

// filmes onde o ano é maior que 2000

> db.filmes.find({"ano":{"$gte":"2000"}})

// Filmes com o ano menor ou igual que 1995

> db.filmes.find({"ano":{"$lte":"1995"}})

// Filmes entre 1995 e 2000

> db.filmes.find({"ano":{"$gte":"1995","$lte":"2000"}})

Usando múltiplos campos

> db.filmes.find({"diretor":"Quentin Tarantino", "ano":
{"$gte":"2000","$lte":"2005"}})

Update (set)

Cuidado Ao utilizar o update, ele altera o documento como um todo e não apenas um campo

Para alterar apenas um campo, use o Operador:

$set: atualiza um campo específico, exemplo:

// Procuro pelo filme que eu quero alterar, pelo campo título e uso o SET, para alterar apenas o campo do título

> db.filmes.update({"titulo" : "Pulp Fiction"},{"$set":
{"titulo":"Pulp Fiction: Tempo de violencia"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

Outros operadores de mudança:

$inc: incrementa o valor atual com o valor passado
$mul: multiplica o valor atual com o valor passado
$rename: renomeia um campo
$unset: remove um campo do documento
$min: atualizar um campo se o valor for menor que o atual
$max: atualiza um campo se o valor for maior

Para alterar todos os documentos encontrados com aquele campo específico, temos que usar a opção multi:true

// fiz uma busca sem usar nada como parâmetro, o que vai me retornar tudo, e depois uso o set para trocar o valor do campo avaliacao.medio para 1

> db.filmes.update({},{"$set":{"avaliacao.medio":1}},
{"multi":true})
WriteResult({ "nMatched" : 23, "nUpserted" : 0, "nModified" : 22 })

// Reparem que ele modificou encontrou 23 e modificou 22, porque um deles o campo já era 1

Delete

Utilizando o operador $unset podemos remover campos de um documento, bastando passar
o campo e o valor como uma string vazia:

> db.filmes.update({},{"$unset":{"avaliacao.medio":""}},{"multi":true})

Finalizando

Por enquanto é isso. Espero que tenha gostado de conhecer os primeiros passos no MongoDB, até a próxima!

 

Anterior Automatização de atendimento com o chatbot Weni
Próxima Upgrade no curso gratuito de Auditoria de Logs da 4Linux

About author

Franklin Ribeiro
Franklin Ribeiro 2 posts

Franklin Ribeiro é bacharel em Sistemas da Informação pela Universidade Bandeirante de São Paulo, possui mais de 10 anos de experiência na área da tecnologia da informação, já atuou em diversas frentes da área e hoje realiza consultoria e treinamento de tecnologias de software livre com ênfase na cultura DevOps e suas ferramentas.

View all posts by this author →

Você pode gostar também

Banco de Dados

4linux moderniza e relança o curso de linguagem sql

DBA moderno precisa ser completo e conhecer a linguagem SQL e suas particularidades para os principais banco de dados do mercado.   Em março/2016 a 4Linux lançou o curso  Administração

Banco de Dados

Lançamento do curso MongoDB.

Big Data e noSQL caminham juntos e com o crescimento de ‘analytics’ nas grandes corporações a busca por profissionais especialista em banco de dados noSQL aumentou na mesma proporção. Além

Banco de Dados

Replicação assíncrona em PostgreSQL 9.6

A replicação de dados tem como propósito garantir a alta disponibilidade de dados. Caso o servidor responsável por receber e alterar dados falhe – seja por problemas de hardware, queda