28/02/2023

MongoDB - Introdução
O MongoDB é um banco de dados não relacional orientado a documentos. Ele
pertence ao novo paradigma de bancos de dados NoSQL (Not Only SQL), onde a
principal característica é ser livre das estruturas tradicionais (tabelas, restrições)
impostas pelo modelo relacional.

2
 28/02/2023

MongoDB - Características
• O projeto do MongoDB (do inglês humongous, “gigantesco”) foi iniciado no ano
de 2007 e a primeira versão disponibilizada em fevereiro de 2009. Seu projeto
inicial e organização do desenvolvimento são mantidos pela empresa 10gen
(www.mongodb.com).

• O banco de dados, que atualmente está na versão 6.0, é desenvolvido em C++

para a construção do seu núcleo e JavaScript para a interface. Possui versões
para vários sistemas operacionais como Windows, Linux, Unix e OSX (MacOS)
de 32 e 64 bits.

• Já possui suporte e interface para as mais diversas linguagens de programação

do mercado, como Java, PHP, Python, Pearl, C, C#, etc.

• Como exposto anteriormente, o MongoDB é orientado a documentos, isso

significa que ao invés de armazenar informações na forma de linhas e colunas
(tabelas) o armazenamento é realizado em forma de documentos, onde as
definições (atributos) e seus valores estão autocontidos em um único local.
3

MongoDB - Características
• Cada documento em si não tem um formato previamente definido e pode ser
modificado conforme a necessidade de utilização da aplicação. O código abaixo
representa a criação de dois documentos pertencentes a uma mesma coleção.
var aluno = {
rm: 999999,
nome: "Pedro Henrique",
curso: "Tecnologia em Banco de Dados",
ano: 2023
}

var aluno = {
rm: 554488,
nome: "Lucas Silva",
curso: "Tecnologia em Banco de Dados",
ano: 2023,
disciplinas: [
"Arquitetura de Banco de Dados",
"Fundamentos de Banco de Dados",
"Programação“
]
} 4

4
 28/02/2023

MongoDB - Características
• Como visto no exemplo anterior, a coleção “aluno” possui um documento com
os atributos RM, nome, curso e ano; e outro documento com os mesmos
atributos e mais o vetor disciplinas. Essa construção, chamada de schemaless
(livre de schema, em tradução livre), não está submetida à rigidez de modelos
de dados relacionais, o que permite uma maior autonomia e agilidade na
definição da informação.

• A característica mais marcante desse banco de dados é a capacidade de

manipular grandes volumes de dados (documentos) não estruturados,
permitindo um desempenho maior que os bancos de dados relacionais.

MongoDB - Terminologia

6
 28/02/2023

MongoDB – Configuração básica

• A configuração do MongoDB é realizada por meio do arquivo de configuração
geralmente localizado em /etc/mongod.conf

MongoDB – Configuração básica

8
 28/02/2023

MongoDB – Configuração básica

MongoDB – Configuração básica

10

10
 28/02/2023

MongoDB – Configuração básica

11

11

MongoDB – JSON
• Como visto no início, o o MongoDB armazena os dados no formato JSON
(JavaScript Object Notation), que possui as seguintes características principais:

• Padrão aberto de intercâmbio de objetos. Muito utilizado no intercâmbio

de informações.

• Baseado na notação JavaScript. É um subconjunto da linguagem

JavaScript, porém não é obrigatório o uso da linguagem para manipulação
dos objetos JSON.

• Adotado por diversas linguagens. Possui suporte em praticamente todas

linguagens de programação (C, C++, C#, Java, JavaScript, Python, Perl,
PL/SQL, etc).

• Referência official: http://www.json.org/json-pt.html

12

12
 28/02/2023

MongoDB – JSON
• É um formato leve, usando notação (chave: valor) em texto simples.

• Por isso tem um tamanho reduzido.

• Pode substituir outros formatos como por exemplo o XML.

13

13

MongoDB – JSON
• Padrão de notação

• Dados definidos com os pares: {chave: valor}. Exemplo:

• var = {professor: “Rodrigo”}

• Dados separados por vírgulas {chave1: valor1, chave2: valor2}. Exemplo:

• var = {professor: “Rodrigo”, disciplina: “Banco de Dados”}

• Colchetes definem matrizes / vetores. Exemplo:

• var = {
professor: “Rodrigo”,
contato: [
{tipo: “celular”, descricao: “95867743”},
{tipo: “email”, descricao: “profrodrigo@fiap.com.br”}
]
}

14

14
 28/02/2023

MongoDB – JSON
• Padrão de notação

• Dados definidos com os pares: {chave: valor}. Exemplo:

• var = {professor: “Rodrigo”}

• Dados separados por vírgulas {chave1: valor1, chave2: valor2}. Exemplo:

• var = {professor: “Rodrigo”, disciplina: “Banco de Dados”}

• Colchetes definem matrizes / vetores. Exemplo:

• var = {
professor: “Rodrigo”,
contato: [
{tipo: “celular”, descricao: “95867743”},
{tipo: “email”, descricao: “profrodrigo@fiap.com.br”}
]
}

15

15

MongoDB – NoSQL

16
16

16
 28/02/2023

Oracle versus MongoDB

Oracle (RDBMS) MongoDB (documento)
Instância de Banco de Dados Instância MongDB
Esquema Banco de Dados
Tabela, View Coleção
Linha Documento (JSON, BSON)
ROWID _id
Junção DBRef (Embedded Document)
Foreign Key Reference
Partição Shard
Select Método find
Insert Método insert
Update Métedo update
Delete Método remove

17
17

17

show
Comando Imprime lista de
show dbs; todos databases no servidor.
show collections; todas coleções do database corrente.
show users; usuários do database corrente.
show roles; roles pré-definidas e definidas pelo usuário do database corrente.
show profile; 5 operações mais recentes que demoraram 1 milisegundo ou mais.
show databases todos databases disponívies.

• show
• Usado para exibir databases, coleções, usuários conectados, roles,
profiles.

18
18

18
 28/02/2023

show dbs;
• show dbs;
• Exibe uma listagem dos databases existentes.
• Dependendo da instalação, o banco vazio local tem 0.078GB pré-
alocado.
• O espaço é pré-alocado por razões de performance e para garantir
espaço sequencial para persistência.
• O banco local é criado durante a instalação do software e seus
arquivos ficam no diretório data.

19
19

19

use
Comando Ação
use <db>; Muda do banco de dados atual para o banco <db>. A variável shell
db é alterada para o banco atual.

• Não existe create database.

• O banco é criado no momento em que é criado uma coleção
• Para entrar em um banco específico é utilizado o comando use.
• O nome do banco não pode conter uma cadeia vazia, um ponto (“.”) ou
palavras reservadas.

20
20

20
 28/02/2023

Database, Coleção e Documento

21
21

21

Coleção
• MongoDB armazena dados na forma de documentos.
• Os documentos são armazenados em formato chave:valor
• Uma coleção é um conjunto de documentos.

22
22
Fonte: MongoDB

22
 28/02/2023

Método createCollection()
Comando Ação
db.createCollection(name, options) Cria, explicitamente, uma coleção

• Cria, explicitamente, uma coleção

• O nome de uma coleção deve começar por uma letra ou sublinhado (“_”).
• Pode conter números.
• Não pode utilizar o caractere cifrão (“$”).
• Não pode exceder 128 caracteres.
• É possível criar grupos nomeados usando um ponto (“.”). Esses grupos são
nomeados de namespace collection.
• Exemplo:
• autor.nome
• autor.area

23
23

23

Método createCollection()
Comando Ação
db.createCollection(name, options) Cria, explicitamente, uma coleção

• Name
• Nome da coleção a ser criada
• Options
• capped – coleção ordenada, circular, de tamanho fixo. Default “false”.
• autoIndexID – cria índice nos campos _id. Default “false”.
• size – define o tamanho, em bytes, de uma coleção capped.
• max – define o número máximo de documentos de uma coleção capped.

db.createCollection(“Produto", { capped : true, autoIndexID : true, size : 6142800, max : 10000 } )

24
24

24
 28/02/2023

Tipo de Dados
• O mongoDB possui suporte aos principais tipos de dados primitivos
utilizados em qualquer banco de dados.
Object ID Object
String Arrays
Integer Double
Boolean Regular expression
Date Timestamp
Null Symbol
Binary data Code
• Dentre os diversos tipos de dados os mais utilizados são os:
• Numéricos
• String (use ‘’ ou “” para identificá-los)
• Date
• Boolean (true ou false)
• Array
25
25

25

Símbolos, Delimitadores e Operadores

Operador Significado
() (parênteses) Indica o uso de um método
[] (colchetes) Usado para arrays
{} (chaves) Usado para documentos
. (ponto) Separador de métodos
= (igual) Atribui valor para variáveis

Símbolo Significado
, (vírgula) Separa atributos. Não deve ser usada com números
: (dois pontos) Especifica o valor de um atributo
‘ (aspas simples) Indica que o valor de um atributo é texto.
“ (aspas duplas) Indica que o valor de um atributo é texto.
; (ponto-e-vírgula) Encerra um comando
26
26

26
 28/02/2023

Método db.collection.insertOne()
Comando Ação
db.collection.insertOne( Insere novos documento(s) em uma
<documento ou array de documentos>, coleção
{writeConcern: <document>,
ordered: <boolean>
}
)

• Insere documento(s) em uma coleção.

• A sintaxe de um comando no MongoDB é:
database.collection.method()
• Documento ou array de documentos
• Documento ou array de documentos a ser inserido em uma coleção
• writeConcern
• Define se a persistência dos dados será acknowledged (w) ou
unacknowledged (j).
• ordered
• Insere os documentos na sequencia que estão no array. Se um erro
ocorrer, os demais documentos do array não serão inseridos. 27
27

27

Método db.collection.insertOne()
db.biblioteca.count();
db.biblioteca.insertOne({Nome:’Banco de Dados’, Autor:’Sandra
Puga’});
db.biblioteca.count();
db.biblioteca.find();
db.biblioteca.find({Autor: “Sandra Puga”});
•db.biblioteca.find({Autor: “Sandra
A coleção só é criada quando Puga”}).pretty();
o primeiro documento é inserido.

• O exemplo efetua a contagem de documentos de uma coleção, acrescenta

um documento a coleção, efetua nova contagem e lista todos os seus
documentos.

28
28

28
 28/02/2023

Método db.collection.insertOne()
db.inventory.insertOne(
{
item: "ABC1",
details: {
model: "14Q3",
manufacturer: "XYZ Company"
},
stock: [ { size: "S", qty: 25 }, { size: "M", qty: 50 } ],
category: "clothing"
}
)
• Insere um documento em uma coleção chamada inventory. A operação irá
criar a coleção, caso ela não exista.

• A operação retorna um objeto WriteResult com o status da operação

29
29

29

Método db.collection.insertOne()
• Para inserir um array de documentos, defina uma variável para conter o
array, exemplo no próximo slide.

• Use a variável no método insertOne(), para executar um bulk insert

• A operação retorna um objeto BulkWriteResult com o status da operação

• O campo nInserted especifica o número de documentos inseridos.

• Cada documento inserido possui seu próprio _id.

30
30

30
 28/02/2023

Método db.collection.insertMany()
var mydocuments =
[
{
item: "ABC2",
details: { model: "14Q3", manufacturer: "M1 Corporation" },
stock: [ { size: "M", qty: 50 } ],
category: "clothing"
},
{
item: "MNO2",
details: { model: "14Q3", manufacturer: "ABC Company" },
stock: [ { size: "S", qty: 5 }, { size: "M", qty: 5 }, { size: "L", qty: 1 } ],
category: "clothing"
},
{
item: "IJK2",
details: { model: "14Q2", manufacturer: "M5 Corporation" },
stock: [ { size: "S", qty: 5 }, { size: "L", qty: 1 } ],
category: "houseware"
}
];

db.inventory.insertMany( mydocuments ); 31
31

31

Método db.collection.insertOne()
show dbs;
use banco;
show collections;
db.Colunas.insertOne({col1:'texto',col2:4});
db.Colunas.find();
db.Colunas.insertOne ({col1:99,col2:‘texto'});
db.Colunas.find();
db.Colunas.insertOne ({col5: 4.3});
db.Colunas.find();
db.Colunas.insertOne ({col2: new Date()});
db.Colunas.find();

db.users.insertOne ({name:"Laura",age:8});
db.users.insertOne ({name:"Sandra",age:33});
db.users.insertOne ({name:"Poyatos",age:35});
db.users.insertOne ({name:"Bianka",age:40});
db.users.insertOne ({name:"Surian",age:65});
db.users.insertOne ({name:"Bob",age:32,job:"Salesman"});
db.users.insertOne ({name:"Joelma",age:27});
db.users.insertOne ({name:"Kimota",age:34});
db.users.insertOne ({name:"King",age:36});
db.users.find();
32
32

32
 28/02/2023

Método db.collection.save()
• O método save() atualiza um documento existente ou inclui um novo.

var x = {col1: 6, col2: 'another string'}

db.ColCreate.save(x)
db.ColCreate.find()

33
33

33

Atributo _id
• Índice único (unique index) criado durante a criação de uma coleção.
• É sempre o primeiro campo de um documento.
• Se o campo _id não for o primeiro em um documento, o servidor
move o campo para o início.
• Cada documento inserido possui seu próprio _id.
• Cada _id é único.
• Normalmente um _id é um tipo de dado ObjectId do BSON com 12 bytes.
• 4 bytes indicam o timestamp da criação do objeto.
• 3 bytes identificam a máquina.
• 2 bytes mostram o identificador (id) do processo.
• 3 bytes contador, iniciado com um valor aleatório.
• Ordenar por _id é o equivalente a ordenar por data de criação.
• O método getTimestamp() acessa a data de criação do objeto.

ObjectId("507f191e810c19729de860ea").getTimestamp()

34
34

34
 28/02/2023

Atributo _id
• É possível atribuir valores a um atributo _id, mas o valor não pode ser
repetido.
• O comportamento é similar uma chave primária em um RDBMS.
• Pode conter qualquer tipo de dados BSON, com exceção de array.
• Expressões regulares são desaconselhadas nesse campo em casos de
replicação.

db.ColPK.insertOne({_id: 1, name: 'first'});

db.ColPK.find();

• O comando abaixo provoca um erro

db.ColPK.insertOne({_id: 1, name: 'second'});

35
35

35

Método find()
• O método db.collection.find() lista os registros de uma coleção.
• Retorna um array com os objetos da coleção, mesmo que a coleção
tenha apenas um objeto.
• Retorna um cursor implícito.
• É preciso iterar o cursor para acessar o documento.
• Se o cursor não for atribuído a uma variável usando a palavra-chave
var o cursor fará 20 iterações automaticamente.

• O método db.collection.find() retorna apenas o primeiro objeto

encontrado.

• Usa-se find() para listagem de registros e find() para consulta de registros

36
36

36
 28/02/2023

Método find()
• Uma consulta vazia ({}) retorna todos os documentos de uma coleção.

• Não especificar uma consulta é o equivalente a uma consulta vazia.

• db.coleção.find() é equivalente a db.coleção.find({})

• É possível efetuar uma consulta por igualdade

• {<campo>: <valor>}
• Neste caso serão listados todos os campos com o valor especificado.

db.biblioteca.find();
db.biblioteca.find({Autor: “Sandra Puga”});

37
37

37

Método find()

• O método find() retorna um ponteiro para todos os documentos

encontrados. Esse ponteiro recebe o nome de cursor.

• Com o método find() é possível encadear diversas funções para melhorar a

busca de documentos.

• cursor.sort(sort) ordena o resultado de uma consulta.

• 1 indica ordem crescente.
• -1 indica ordem decrescente

{ age : -1, posts: 1 }

38
38

38
 28/02/2023

Método find()

• Dependendo do plano de acesso da consulta, o processo de classificação

pode ser substituído por uma varredura de índices. Nesse caso, a
classificação dos dados não será feita em memória.

• Ocorrerá um erro se uma operação de classificação ocupar mais de 32

megabytes na memória.

• É possível usar o método limit() para restringir a quantidade de elementos

retornados pela consulta.

var cursor = db.biblioteca.find();

cursor
db.biblioteca.find().sort({Autor: 1});
db.biblioteca.find().sort({Autor: -1}).limit(2);

39
39

39

Método find()
• Operadores aritméticos de comparação:

• $lt (less than).

• db.colecao.find({ "campo" : { $lt: value } } );
• Retorna documentos com valores menores que value.
• $lte (less than or equal)
• db.colecao.find({ "campo" : { $lte: value } } );
• Retorna documentos com valores menores ou igual que value.
• $gt (greater than)
• db.colecao.find({ "campo" : { $gt: value } } );
• Retorna documentos com valores maiores que value.
• $gte (greater than or equal)
• db.colecao.find({ "campo" : { $gte: value } } );
• Retorna documentos com valores maiores ou igual que value.

40
40

40
 28/02/2023

Método find()
SQL
SELECT * FROM users
SELECT * FROM users WHERE age = 33
SELECT * FROM users WHERE age > 33
SELECT * FROM users WHERE age >= 33
SELECT * FROM users WHERE age < 33
SELECT * FROM users WHERE age <= 33
MongoDB
db.users.find()
db.users.find({age: 33})
db.users.find({age: {$gt: 33}})
db.users.find({age: {$gte: 33}})
db.users.find({age: {$lt: 33}})
db.users.find({age: {$lte: 33}})

• db.emp.find({job: "MANAGER"});
• db.emp.find({job: "MANAGER"}).pretty();
• db.emp.findOne({job: "MANAGER"});

41
41

41

Método find()
• Operadores Lógicos:

• $or
• Retorna documentos caso uma das cláusulas for verdadeira.

db.inventory.find( { $or: [ { qty: { $gt: 100 } }, { price: { $lt: 9.95 } } ] })

• $nor
• Retorna documentos que não satisfaçam a cláusula.

db.inventory.find( { $nor: [ { price: 1.99 }, { sale: true } ] } )

• $and
• Retorna documentos caso todas as cláusula forem verdadeiras.

db.inventory.find( { type: 'food', price: { $lt: 9.95 } } )

42
42

42
 28/02/2023

Método find()

SQL MongoDB
SELECT * FROM users WHERE age > 33 db.users.find({age: {$gt: 33, $lt: 40}})
AND age < 40
SELECT * FROM users WHERE age = 32 db.users.find({age: 32, name: “Bob”})
AND name = ‘Bob’
SELECT * FROM users WHERE age = 33 db.users.find({$or:[{age:33},
OR name = ‘Bob’ {name:“Bob”}]})
SELECT * FROM users WHERE age >= 32 db.users.find(age: {$gte:32}, $or: [{name:
AND (name = ‘Bob’ OR job=‘Salesman’) “Bob"}, {job: “Salesman"}] })

43
43

43

Método find()
• $exists
• Retorna documentos que contenham um determinado campo.

db.records.find( { a: { $exists: true } } )

• $in
• Retorna documentos cujo valor de um campo esteja listado em
um array

db.inventory.find( { qty: { $in: [ 5, 15 ] } } )

• $nin
• Retorna documentos cujo valor de um campo não esteja listado
em um array ou dos documentos onde o campo não exista.

db.inventory.find( { qty: { $nin: [ 5, 15 ] } } )

db.inventory.find( { qty: { $exists: true, $nin: [ 5, 15 ] } } )

44
44

44
 28/02/2023

Método find()

SQL MongoDB
SELECT COUNT(job) FROM users db.users.find({job: {$exists: true}}).count()
SELECT * FROM users WHERE age IN db.users.find({age: { $in: [ 32, 33 ] }})
(32, 33)
SELECT * FROM users WHERE age NOT db.users.find({age: { $nin: [ 32, 33 ] }})
IN (32, 33)

45
45

45

Método
• $all
find()
• Retorna documentos que contenham todos os elementos de um
array. Mesmo comportamento de $and

db.articles.find( { tags: { $all: [ [ "ssl", "security" ] ] } } )

• $ne
• Retorna documentos cujo valor seja diferente do informado

db.inventory.find( { qty: { $ne: 20 } } )

• $not
• Efetua uma operação de NOT lógica.

db.inventory.find( { price: { $not: { $gt: 1.99 } } } )

• $mod
• Retorna os documentos cujo resto da divisão atendam um
critério.
db.inventory.find({ value: {$mod: [2,0]}}) 46
46

46
 28/02/2023

Método find()
SQL MongoDB
SELECT * FROM users WHERE a(i) = 10 db.users.find{a: {$all: [10, “hello”]}}
AND a(i+1) = “hello”
SELECT * FROM users WHERE age <>32 db.users.find({age: { $ne: 32 }})

SELECT * FROM users WHERE age NOT db. users.find( {age: { $not: { $gt: 32 } } } )
> 32

47
47

47

Método find()
• Projection é um objeto que passado como parâmetro do método
find(), com o intuito de obter somente os campos que precisamos.

db.inventory.find({_id:3}, { _id:0, price:1, qty:1 })

• Retorna apenas os campos indicados com 1 ou true. O exemplo irá

exibir apenas os campos price e qty. O campo _id não será exibido

• $regex
• Permite o uso de expressões regulares.

db.inventory.find ({ name: {$regex: “i"} })

db.inventory.find ({ name: {$regex: “^K"} })
db.inventory.find ({ name: {$regex: “g$"} })

48
48

48
 28/02/2023

Método find()
SQL MongoDB
SELECT name, age FROM users db.users.find({}, {name: 1, age: 1, _id:0})
SELECT name, age FROM users db.users.find({age: 33}, {name: 1, age: 1,
WHERE age = 33 _id:0})
SELECT * FROM users WHERE name db.users.find({name: /Joe/})
LIKE ‘%Joe%’
SELECT * FROM users WHERE name db.users.find({name: {$regex: “Joe"} })
LIKE ‘%Joe%’

49
49

49

Método updateOne()
• Modifica um ou mais documentos em uma coleção. Pode modificar um
campo específico ou substituir um documento existente.

• Se o parâmetro multi estiver ligado (TRUE), atualiza todos os documentos

que atendam o critério de seleção.

• Se o parâmetro multi estiver desligado (FALSE), atualiza apenas um

documento.

• Existem dois métodos para alterar um documento:

• save()
• update()

50
50

50
 28/02/2023

Método updateOne()
• O método save() necessita buscar o documento antes de alterá-lo.

• O método updateOne() localiza o documento e o altera. Recebe três

parâmetros:
• Query
• Modificação
• Options

db.collection.updateOne(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>,
writeConcern: <document>
}
)

51
51

51

Método updateMany()
• Exemplo

use banco;

db.users.insertOne({name: "Bob", age: 33});

db.users.find().pretty();
{ "_id" : ObjectId("56a6566b040479f0278f3607"), "name" : "Bob", "age" : 33 }

db.users.updateMany({"_id" : ObjectId("56a6566b040479f0278f3607")},
{País:"Honduras", Capital: "Tegucigalpa"});

db.users.find().pretty();

52
52

52
 28/02/2023

Método updateMany()
• $set
• Modifica o conteúdo de um campo específico.
• Se o campo não existir, um novo campo será adicionado ao
documento.

• $inc
• Incrementa o conteúdo de um campo.

• $unset
• Remove um campo de um documento.

• $rename
• Altera o nome de um campo em um documento.

53
53

53

Método updateMany()
• Exemplo

use banco;

db.users.insertOne({name: "Bob", age: 33});

db.users.updateMany({name: "Bob"}, {$inc: { age: 5}});
db.users.find({name: "Bob"}).pretty();

db.users.updateMany({name: "Bob"}, {$set: { age: 33}});

db.users.find({name: "Bob"}).pretty();

db.users.updateMany({name: "Bob"}, {$set: { qty: 5}});

db.users.find({name: "Bob"}).pretty();

db.users.updateMany({name: "Bob"}, {$rename: { 'qty': 'qtdade'}});

db.users.find({name: "Bob"}).pretty();

db.users.updateMany({name: "Bob"}, {$unset: { qtdade : ""}});

db.users.find({name: "Bob"}).pretty(); 54
54

54
 28/02/2023

Método updateMany()
SQL MongoDB
UPDATE users SET age = 33 WHERE db.users.updateMany({name: “Bob”}, {$set: {age:
name = ‘Bob’ 33}})
UPDATE users SET age = age + 2 db.users.updateMany({name: “Bob”}, {$inc: {age:
WHERE name = ‘Bob’ 2}})

55
55

55

Método deleteOne()
• Remove os dados de uma coleção.

• A coleção continua existindo, mesmo sem dados.

• Se o campo não existir, um novo campo será adicionado ao
documento.

• db.collection.deleteOne( <query>)

• <query> especifica os critérios de deleção. Para apagar todos os

documentos de uma coleção basta especificar um documento vazio
({}).

56
56

56
 28/02/2023

Método removeMany()
• Exemplo

use scott;
db.emp.insert({empno:7369, ename: "SMITH", job: "CLERK“});
db.emp.insert({empno:7499, ename: "ALLEN", job: " CLERK "});
db.emp.insert({empno:7521, ename: "WARD", job: " CLERK "});
db.emp.insert({empno:7566, ename: "JONES", job: " CLERK "});

db.emp.deleteMany({empno: { $gt: 7521}});

db.emp.deleteMany({job: “CLERK”} , true);
db.emp.deleteMany({});

57
57

57

Método deleteMany()
SQL MongoDB
DELETE FROM users WHERE name = ‘Bob’ db.users.deleteMany({name:
“Bob”})

58
58

58
 28/02/2023

Copyright ©
© 2023
2015 Prof.
Prof. Rodrigo
LeandroSakai
Rubim

Todos direitos reservados. Reprodução ou divulgação total ou parcial deste

documento é expressamente proíbido sem o consentimento formal, por
escrito, do Professor (autor).

59