03 MongoDB Flashcards
Modelos de Dados Agregados
(inexistente no modelo de dados relacionais)
(é preciso saber como e o que deseja-se saber)
(conhecimento da estrutura agregada ajuda a armazenar e distribuir os dados)
Trabalha-se com todos os dados reunidos
CRUD
Create
Read
Update
Delete
show dbs
mostra as databases instaladas
admin, config e local estâo automaticamente criados
use databaseX
switch or create and switch to databaseX
db.collectionX.insertOne( { Y } )
acrescenta na coleção collectionX (se a coleção não existe, é imediatamente criada), o documento (único) Y
Lembrar do parênteses e chaves
db.collectionX.insertOne( {
Y
} )
acrescenta na coleção collectionX (se a coleção não existe, é imediatamente criada), o documento (único) Y
Lembrar do parênteses e chaves
_id
Identificador aleatoriamente gerado, ou podemos definir se for do interesse
Não pode estar duplicado na mesma coleção ou database ?
db.collectionX.find( )
vs
db.collectionX.find( ).pretty( )
Tudo na mesma linha
Tudo arrumadinho
db.collectionX.deleteOne( {keyX: valueX} )
Deleta o primeiro documento com aquele valor naquela chave
db.collectionX.updateOne( { “filterX”: “valueX”}, { $set {“newLineX”: “valueY”} })
acrescenta newLineX: ValueY onde tem o value X na key filterX
db.collectionX.updateOne( { “filterX”: “valueX”}, { $set {“newLineX”: “valueY”} })
acrescenta newLineX: ValueY onde tem o value X na key filterX
db.collectionX.updateMany( { }, {markerX: “valueX”} )
adiciona o valueX a todos documentos da collectionX
db.collectionX.updateMany( { }, {markerX: “valueX”} )
adiciona ou substitue pelo valueX a todos documentos da collectionX
db.collectionX.insertMany ( [
{
"key1": "valueX1"
"key2": "valueX2"
"key3": "valueX3"
}
{
"key1": "valueY1"
"key2": "valueY2"
"key3": "valueY3"
}
] )Insere esses 2 documentos
db.collectionX.find( { filterX: “value Y”} )
tudo que tiver o valor “value Y” na chave “filter X” será retornado
db.collectionX.find( { numberX: {$gt: #Y} } )
numberX = qualquer chave cujos valores serão numéricos $gt (greater than), $lte (lower or equal than), etc #Y - valor numerico qualquer
db.collectionX.updateOne( {“key1”: “valueX1”}, {$set “key2”: “newValue2”} )
No primeiro documento com Key1=valueX1, muda o valor da key2 para newValue2
db.collectionX.update( {“key1”: “valueX1”}, {“key2”: “newValue2”} )
Onde tiver key1=valueX1 , deleta tudo e fica só “key2”: “newValue2”}
melhor usar updateOne e updateMany
db.collectionX.replaceOne( {“key1”: “valueX1”}, {“key2”: “newValue2”} )
substitui tudo no documento que tem key1=valueX1 por key2=newValue2 (poderiam ser várias linhas)
Objetivo final de projection:
Reduzir consumo de dados
db.collectionX.find ( { }, {keyX: 1, _id: 0} ).pretty()
Projection
Vai devolver todos os docs (filtro é { } ou seja, todos)
Mas só vai devolver a KeyX:ValueX de cada um (1 é sim). Não vai devolver a _id (0 é não, se não especificar devolve a _id por padrão). Não vai devolver nenhuma outra keyY, KeyZ etc porque o padrão destas é 0.
Embedded Documents = Nested documents
Documentos podem ter documentos dentro deles (total de 100 em hierarquia, portanto infinito) 100 levels of nesting
máximo 16mb/documento
db.collectionX.updateMany ( { }, {$set: {key1: {key2: “value2”, key3: “value3”, key4: {key5: “value5”, key6: “value6”}}}})
Adiciona a todos ( { } ) os objetos da collectionX, a key1 que contem a key2, key3 e key4, a key4 contem a key5 e key6.
Arrays = [ ]
List of Documents (tradução é matriz)
db.collectionX.updateOne ( {keyX= 666}, {$set: {keyY: [“bla”, “kkk”, “LOL”] } } )
no documento em que keyX=666, acrescenta na keyY uma array com as strings bla, kkk e LOL.
db.collectionX.findOne( {keyX: 99} ).keyY
Retorna o valueY do documento em que KeyX=99
db.collectionX.find ( {“keyX.keyY”: “valueY”} )
retorna os documentos cujo valor da keyY que está dentro da keyX, é valueY
MongoDB enforces no schemas! Documents don`t have to use the same schema inside of one collection!
But that does not mean that you can`t use some kind of schema!
But we probably prefer some kind of schema!
DATA TYPES
Text: " bla bla bla"
Boolean: true or false
Numbers: Integer(int32), NumberLong(int64), NumberDecimal (são os double, 2 números decimais)
ObjectId (respects timestamps)
ISODate("yyyy-mm-dd")
Timestamp("garante que dois objetos criados ao mesmo tempo tem diferente timestamp")
Embedded Document
Arraysnew Date
new Timestamp
adiciona data atual
adiciona tempo atual
db.stats ( )
mostra espaço ocupado e diversas outras informações
typeof ( etc )
tipo do objeto
Important data type limits are:
Normal integers (int32) can hold a maximum value of +-2,147,483,647
Long integers (int64) can hold a maximum value of +-9,223,372,036,854,775,807
Text can be as long as you want - the limit is the 16mb restriction for the overall document
It’s also important to understand the difference between int32 (NumberInt), int64 (NumberLong) and a normal number as you can enter it in the shell. The same goes for a normal double and NumberDecimal.
NumberInt creates a int32 value => NumberInt(55)
NumberLong creates a int64 value => NumberLong(7489729384792)
If you just use a number (e.g. insertOne({a: 1}), this will get added as a normal double into the database. The reason for this is that the shell is based on JS which only knows float/ double values and doesn’t differ between integers and floats.
NumberDecimal creates a high-precision double value => NumberDecimal(“12.99”) => This can be helpful for cases where you need (many) exact decimal places for calculations.
When not working with the shell but a MongoDB driver for your app programming language (e.g. PHP, .NET, Node.js, …), you can use the driver to create these specific numbers.
Example for Node.js: http://mongodb.github.io/node-mongodb-native/3.1/api/Long.html
This will allow you to build a NumberLong value like this:
const Long = require(‘mongodb’).Long;
db.collection(‘wealth’).insert( {
value: Long.fromString(“121949898291”)
});
By browsing the API docs for the driver you’re using, you’ll be able to identify the methods for building int32s, int64s etc.
NESTED / EMBEDDED DOCUMENTS
Group data together logically
Great for data that belongs together and is not really overlapping with other data
Avoid super-deep nesting (100+lvls) or extremely long arrays (16mb size limit per document)
REFERENCES
Splita data across collections
Great for related but shared dat as well as for data which is used in relations and standalone
Allows you to overcome nesting and size limits (by creating new documents)
validationLevel
validationAction
which documents get validated?
strict = all inserts and updates
moderate = all inserts and updates to correct documents
what happens if validation fails?
erros = throw error and deny insert/update
warn = log warning but proceed
validationLevel
validationAction
which documents get validated?
strict = all inserts and updates
moderate = all inserts and updates to correct documents
what happens if validation fails?
erros = throw error and deny insert/update
warn = log warning but proceed
db.createCollection(“collectionX”, {validator: {$jasonSchema: {bla bla bla, bsonType: “ex: object”, required: [“keyX”, keyY”, “keyZ”], properties (exemplo: bsonType de cada objeto anterior, etc, comentário, descrição) } } } )
Exemplo do outro lado
db.createCollection(‘posts’, {
validator: {
$jsonSchema: {
bsonType: ‘object’,
required: [‘title’, ‘text’, ‘creator’, ‘comments’],
properties: {
title: {
bsonType: ‘string’,
description: ‘must be a string and is required’
},
text: {
bsonType: ‘string’,
description: ‘must be a string and is required’
},
creator: {
bsonType: ‘objectId’,
description: ‘must be an objectid and is required’
},
comments: {
bsonType: ‘array’,
description: ‘must be an array and is required’,
items: {
bsonType: ‘object’,
required: [‘text’, ‘author’],
properties: {
text: {
bsonType: ‘string’,
description: ‘must be a string and is required’
},
author: {
bsonType: ‘objectId’,
description: ‘must be an objectid and is required’
}
}
}
}
}
}
}
});
db.runCommand ( { collMod: “collectionX”, } )
collMod = collection modifier
db.runCommand({
collMod: 'posts',
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['title', 'text', 'creator', 'comments'],
properties: {
title: {
bsonType: 'string',
description: 'must be a string and is required'
},
text: {
bsonType: 'string',
description: 'must be a string and is required'
},
creator: {
bsonType: 'objectId',
description: 'must be an objectid and is required'
},
comments: {
bsonType: 'array',
description: 'must be an array and is required',
items: {
bsonType: 'object',
required: ['text', 'author'],
properties: {
text: {
bsonType: 'string',
description: 'must be a string and is required'
},
author: {
bsonType: 'objectId',
description: 'must be an objectid and is required'
}
}
}
}
}
}
},
validationAction: 'warn' (ORRRRR ERROR QUE É O PADRÃO SE NAO ESPECIFICAR)
});insertOne ( )
x
insertMany ( )
x
insert ( )
+ mongoimport
insert é o antigo, dá muito problema, evitar usar
usar insertOne e insertMany
db. dropDatabase ( )
db. collectionX.drop ( )
deleta a database em uso atual
deleta a collectionX
insertMany is “ordered” insert
(default behavior)
if you insert [ {1}, {2}, {3} ], what happens if {2} got error?
MongoDB insere somente o {1} porque não faz rollback e nem continua a inserir
Como mudar isso?
db.collectionX.insertMany ( [ {1}, {2}, {3} ], {ordered: false} )
Desta forma vai inserir { 1 } e { 3 } porque o último não tem erro
ordered: true é o default
writeConcern
{ w: 1, wtimeout: 666, j true}
w = write, 1 significa que vai escrever
wtimeout = define o tempo que dá erro se não conseguir escrever no servidor
j = journal , se true usa ele, se undefined não usa ele
journal é o backup de “to do list”
…{writeConcern: {w:1, j: true}})
Como importar .json pro mongo
mongoimport original.json -d movieData -c movies –jsonArray –drop
1) sair do mongo (exit)
2) abrir powershell / terminal
3) navegar até onde está o arquivo (cd etc)
4) mongoimport fileX.json -d databaseX -c collectionX –jsonArray –drop
- -jsonArray (adiciona tudo)
- drop (deleta o que estiver naquela databse se existir)
Comparison Operators
db.collectionX.find ( { key1: {$xx: valueX} } )
$eq Matches values that are equal to a specified value.
$gt Matches values that are greater than a specified value.
$gte Matches values that are greater than or equal to a specified value.
$in Matches any of the values specified in an array.
$lt Matches values that are less than a specified value.
$lte Matches values that are less than or equal to a specified value.
$ne Matches all values that are not equal to a specified value.
$nin Matches none of the values specified in an array.
What this command works for:
db.movies.find({“rating.average”: {$gt: 7}}).toArray()
Na database atual (db), na coleção movies, procura e retorna (find), todos os campos em que average que está dentro de ratingo tem valor maior que 7 ($gt = greater than). Todos os valores são retornados toArray() (ou seja, até o final do documento, e automaticamente no formato .pretty() )
db.movies.find({“rating.average”: {$gt: 7}}).toArray()
Na database atual (db), na coleção movies, procura e retorna (find), todos os campos em que average que está dentro de ratingo tem valor maior que 7 ($gt = greater than). Todos os valores são retornados toArray() (ou seja, até o final do documento, e automaticamente no formato .pretty() )
O que o comando abaixo faz:
db.movies.find( {runtime: {$in: [30, 42] } } ).toArray ( )
Retorna todos os filmes com tempo de 30 ou 42, não retorna 31, 29, 43, etc…
$nin retornaria exatamente o contrário
db.movies.find( {runtime: {$in: [30, 42] } } ).toArray ( )
Retorna todos os filmes com tempo de 30 ou 42, não retorna 31, 29, 43, etc…
$nin retornaria exatamente o contrário
…find().count()
quantidade que retornaria
db.movies.find ( { $or: [ {“rating.average”: {$lt: 5} }, {“rating.average”: {$gt: 9.3} } ] } ).toArray ( )
retorna todos os filmes com nota menor que 5 ou nota maior que 9.3
$nor seria o contrário
(todos documentos não inclusos acima)
db.movies.find( {$and: [ {“rating.average”: {$gt: 9} }, {“genres”: “Drama”} ] } ).toArray ( )
(método antigo)
db.movies.find ( {“rating.average”: {$gt: 9}, “genres”: “Drama”} ).toArray ( )
(método atual)
retorna todos os filmes com gênero drama e nota maior que 9
$and é necessário quando vai usar dois filtros do mesmo campo (mesma key)
