Aprendendo MongoDb a partir do Relacional

Há uma coisa bem diferente no MongoDB para quem vem do relacional são seus operadores. Eles são responsáveis por fazer alguma ação que no SQL é escrito, no MongoDB será um operador, por exemplo:

$set: modifica valores e cria campos

{ $set: {campo: valor} }

No MongoDb possuimos diversos operadores que são separados da seguinte forma:

Dê uma conferida na documentação oficial do MongoDb que para mim é uma das mais completas e bonitas que conheço dos projetos que EU uso, caso você conheça uma mais bonita comente aqui por favor.

Chegamos no ponto principal desse manual, as queries em SQL, então vamos para de enrolação e ir direto ao ponto.

SQLs

INSERT

INSERT INTO tabela VALUES  
Model.save(data, callback);  

UPDATE

UPDATE tabela SET campo=valor WHERE id=1  
Model.update(query, modificador, callback);  

Aqui no UPDATE o WHERE será nosso objeto query e o SET campo=valor será nosso objeto modificador.

Exemplo:

SQL:

UPDATE webschool.ebooks SET author='Suissa' WHERE title='Be MEAN'  

MongoDB:

var query = { title: 'Be MEAN' },  
    mod = { $set: {author: 'Suissa'} };

db.colecao.update(query, mod, callback);  

Perceba que na SQL utilizamos SET para setar os valores, assim como no MongoDB

DELETE

DELETE FROM tabela  
Model.remove(query, callback);  
DELETE FROM tabela WHERE title='Be MEAN'

var query = { title: 'Be MEAN' };  
Model.remove(query, callback);  

SELECT

SELECT * FROM tabela  
Model.find({}, callback);  

Aqui no SELECT o * será nosso objeto {}.

Agora fazendo a busca por algum valor:

SELECT * FROM tabela WHERE title='Be MEAN'


// MongoDb
var query = {title: 'Be MEAN'};  
Model.find(query, callback)  

Nesse caso o WHERE vira nosso objeto que query, porém como o Javascript é case sensitive se eu tentasse fazer a busca por 'be mean' não retornaria nenhum resultado.
Para contornar esse probleminha podemos utilizar nossa querida e amada RegEx ficando assim:

SELECT * FROM tabela WHERE title='Be MEAN'


// MongoDb
var query = {title: /be mean/i};

Model.find(query, callback);  

Basicamente você precisa colocar seu valor entre as / / e o i no final é para ser insensitive.

Bom você deve ter percebido que estamos retornando todos os campos e se eu quisesse retornar apenas os campos: author e title.

SELECT author, title FROM tabela WHERE title='Be MEAN'


// MongoDb
var fields = {author: 1, title:1},  
    query = {title: /be mean/i};

Model.find(query, fields, callback);  

Para selecionarmos apenas os campos que precisamos criamos um objeto passando o nome do campo: boolean, nesse exemplo o _id ainda é retornado, para eliminarmos também o _id só precisamos passar false.

var fields = {author: 1, title: 1, _id: 0},  
    query = {title: /be mean/i};

Model.find(query, fields, callback);  

Porém nós ainda não estamos ordenando e nem agrupando nossos resultados, para utilizar a ordenação no MongoDb é bem simples:

SELECT author, title FROM tabela ORDER BY author ASC  
SELECT author, title FROM tabela ORDER BY author DESC


// MongoDb
var fields = {author: 1, title:1},  
    query = {};

Model.find(query, fields, callback).sort({author: 1});  
Model.find(query, fields, callback).sort({author: -1});  

Como você deve ter percebido utilizamos a função sort encadeada com a find, te deu saudades do jQuery neh safado! E claramente percebemos que o ASC na SQL vira 1 no MongoDb, o que significa que ele irá ordenar seus resultados do menor para o maior ou nesse caso de A a Z. E o DESC vira -1 que significa descendente ou nesse caso de Z a A.

Legal já estou ordenando meus resultados, mas como eu posso limitar a quantidade de resultados retornados?

Fácil, com LIMIT.

SELECT author, title FROM tabela ORDER BY author ASC LIMIT 10  
SELECT author, title FROM tabela ORDER BY author DESC LIMIT 10


// MongoDb
var fields = {author: 1, title:1},  
    query = {};

Model.find(query, fields, callback).sort({author: 1}).limit(10);  
Model.find(query, fields, callback).sort({author: -1}).limit(10);  

Muito fácil não? Agora chegamos em um ponto interessante com essa query.

Caso você trabalhe com Backend muito provavelmente precisou fazer uma paginação dos resultados, aliás isso também pode e deve ser aplicado para retornar uma quantidade máxima de resultados sem onerar seu sistema.

Para criar uma função de paginação precisamos utilizar o OFFSET que tem a função de pular uma quantidade x de objetos, porém no MongoDb vamos utilizar a função skip.

SELECT author, title FROM tabela ORDER BY author ASC LIMIT 10  
SELECT author, title FROM tabela ORDER BY author DESC LIMIT 10


// MongoDb
var fields = {author: 1, title:1},  
    query = {};

Model.find(query, fields, callback).sort({author: 1}).limit(10).skip(10);  
Model.find(query, fields, callback).sort({author: -1}).limit(10).skip(10);  

Ueh! Mas não entendi onde entra a paginação nesse código ai.

Então deixa eu demonstrar com código! Talk is cheap! Show me the code!

var fields = {author: 1, title:1},  
    query = {},
    limit = 10;

var skip = numero_da_pagina * limit;

Model.find(query, fields, callback).sort({author: 1}).limit(limit).skip(skip);  

Não entendeu ainda? Então vamos fazer um teste de mesa:

  • página 0
    • limit = 10
    • skip = 0 * 10
    • skip = 0

Na página 0, se você quer começar com 1 fique a vontade só não esqueca de subtrair ele do número da página na função, o MongoDb irá retornar os 10 primeiros registros, agora vamos para a próxima página:

  • página 1
    • limit = 10
    • skip = 1 * 10
    • skip = 10

Já na página 1 o MongoDb irá pular os 10 primeiros registros e retornará os 10 próximos

  • página 2
    • limit = 10
    • skip = 2 * 10
    • skip = 20

Já na página 2 o MongoDb irá pular os 10 primeiros registros e retornará os 10 próximos e assim por diante. Agora deve ter ficado claro como podemos criar uma função simples de paginação.

Operadores de Busca

Comparação

  • $gt: Maior que.
  • $gte: Maior que ou igual.
  • $in: Procura por valores dentro de um array.
  • $lt: Menor que.
  • $lte: Menor que ou igual.
  • $ne: Procura valores que não sejam igual ao valor repassado (not equal).
  • $nin: Procura valores que não existem dentro de um array.

Lógico

Elemento

ESSE POST VAI SER ATUALIZADO E COMPLETADO MAS ACEITO SUGESTÕES DO QUE EXPLICAR

TODO:

  • GROUP BY: aggregate
  • Tabela = Coleção
  • PK = _id
  • FK
  • 1:N
  • N:N
  • Partition = Shard
  • Replica = Replica

Comentários

comments powered by Disqus