Banco de Dados NoSQL com MongoDB_Final

Prévia do material em texto

Brasília-DF. 
Banco de dados nosql com mongodB
Elaboração
Leandro Cavalcanti de Santana
Produção
Equipe Técnica de Avaliação, Revisão Linguística e Editoração
Sumário
APrESEntAção ................................................................................................................................. 4
orgAnizAção do CAdErno dE EStudoS E PESquiSA .................................................................... 5
introdução.................................................................................................................................... 7
unidAdE i
Fundamentos do mongodB ............................................................................................................ 9
CAPítulo 1
examinando a FilosoFia do mongodB ............................................................................. 9
CAPítulo 2
entendendo as partes do mongodB ............................................................................... 16
CAPítulo 3
examinando a lista de recursos ...................................................................................... 20
unidAdE ii
Fazendo a instalação do mongodB ............................................................................................ 28
CAPítulo 1
Qual sistema usar? ............................................................................................................. 28
CAPítulo 2
mongodB em execução ................................................................................................... 32
CAPítulo 3
suporte de drivers ............................................................................................................. 35
unidAdE iii
modelagem do mongodB ............................................................................................................. 40
CAPítulo 1
como modelar? ................................................................................................................ 40
CAPítulo 2
momento integração ....................................................................................................... 49
CAPítulo 3
e o Que esperar do mongodB? Fazendo um overview! ................................................ 61
unidAdE iV
atividade prática .............................................................................................................................. 65
CAPítulo 1
vamos Que vamos! ............................................................................................................. 65
CAPítulo 2
gridFs! ................................................................................................................................. 79
rEfErênCiAS .................................................................................................................................. 85
5
Apresentação
Caro aluno
A proposta editorial deste Caderno de Estudos e Pesquisa reúne elementos que se 
entendem necessários para o desenvolvimento do estudo com segurança e qualidade. 
Caracteriza-se pela atualidade, dinâmica e pertinência de seu conteúdo, bem como pela 
interatividade e modernidade de sua estrutura formal, adequadas à metodologia da 
Educação a Distância – EaD.
Pretende-se, com este material, levá-lo à reflexão e à compreensão da pluralidade 
dos conhecimentos a serem oferecidos, possibilitando-lhe ampliar conceitos 
específicos da área e atuar de forma competente e conscienciosa, como convém 
ao profissional que busca a formação continuada para vencer os desafios que a 
evolução científico-tecnológica impõe ao mundo contemporâneo.
Elaborou-se a presente publicação com a intenção de torná-la subsídio valioso, de modo 
a facilitar sua caminhada na trajetória a ser percorrida tanto na vida pessoal quanto na 
profissional. Utilize-a como instrumento para seu sucesso na carreira.
Conselho Editorial
6
organização do Caderno 
de Estudos e Pesquisa
Para facilitar seu estudo, os conteúdos são organizados em unidades, subdivididas em 
capítulos, de forma didática, objetiva e coerente. Eles serão abordados por meio de textos 
básicos, com questões para reflexão, entre outros recursos editoriais que visam tornar 
sua leitura mais agradável. Ao final, serão indicadas, também, fontes de consulta para 
aprofundar seus estudos com leituras e pesquisas complementares.
A seguir, apresentamos uma breve descrição dos ícones utilizados na organização dos 
Cadernos de Estudos e Pesquisa.
Provocação
Textos que buscam instigar o aluno a refletir sobre determinado assunto antes 
mesmo de iniciar sua leitura ou após algum trecho pertinente para o autor 
conteudista.
Para refletir
Questões inseridas no decorrer do estudo a fim de que o aluno faça uma pausa e reflita 
sobre o conteúdo estudado ou temas que o ajudem em seu raciocínio. É importante 
que ele verifique seus conhecimentos, suas experiências e seus sentimentos. As 
reflexões são o ponto de partida para a construção de suas conclusões.
Sugestão de estudo complementar
Sugestões de leituras adicionais, filmes e sites para aprofundamento do estudo, 
discussões em fóruns ou encontros presenciais quando for o caso.
Atenção
Chamadas para alertar detalhes/tópicos importantes que contribuam para a 
síntese/conclusão do assunto abordado.
7
Saiba mais
Informações complementares para elucidar a construção das sínteses/conclusões 
sobre o assunto abordado.
Sintetizando
Trecho que busca resumir informações relevantes do conteúdo, facilitando o 
entendimento pelo aluno sobre trechos mais complexos.
Para (não) finalizar
Texto integrador, ao final do módulo, que motiva o aluno a continuar a aprendizagem 
ou estimula ponderações complementares sobre o módulo estudado.
8
introdução
Neste material de apoio você irá encontrar de forma simples e prática o assunto da 
disciplina de Banco de Dados NoSQL com MongoDB. O conteúdo foi produzido e 
organizado por Leandro Cavalcanti, que possui graduação em Sistemas de Informação 
pela Universidade Federal Rural de Pernambuco e mestrado em Engenharia da 
Computação pela Universidade de Pernambuco. 
O material divide-se em: Unidade 1, faz uma abordagem aos conceitos de fundamentos 
do MongoDB. Unidade 2, são apresentados os modelos e métodos de instalação e 
configuração do MongoDB. A Unidade 3 é voltada para modelagem do Banco de Dados 
e expectativas da tecnologia. Por fim, a Unidade 4 é proposta uma atividade prática. 
É possível encontrar um material complementar em: <https://www.devmedia.com.
br/introducao-ao-mongodb/30792>.
objetivos
 » Apresentar os conceitos e fundamentos do MongoDB.
 » Conhecer os drivers de instalação.
 » Analisar os processos de instalação e suas instâncias.
 » Entender a modelagem do banco de dados.
 » Desenvolver uma atividade prática.
9
unidAdE ifundAmEntoS do 
mongodB
CAPítulo 1
Examinando a filosofia do mongodB
Há décadas, os bancos de dados relacionais tradicionais (SQL) servem para armazenar 
qualquer tipo de dados, por exemplo: Oracle, PostgreSQL, MySQL, SQLite, MS SQL 
Server.
A proposta da equipe do MongoDB é: não criar um BD que tente resolver tudo e 
todos os problemas. Ao invés disso, precisávamos criar um BD que funcionasse com 
documentos em vez de linhas, que fosse muito rápido, escalável e fácil de usar. Para que 
isso aconteça, é necessário descartar alguns recursos, o que significa que esta solução 
não se encaixa em todos os aspectos. Por exemplo, o fato de não existir suporte às 
transações significa que o MongoDB não deve ser usado para o desenvolvimento de um 
aplicativo contábil. 
O MongoDB é bom para ser aproveitado em uma parte do aplicativo mencionado 
(para armazenar dados complexos). No entanto, isso não é um problema, uma vez que 
não há motivo para não usar um RDBMS (Relational DataBase Management System) 
tradicional para componentes contábeis e MongoDB para arquivamento de documentos. 
Soluções híbridas como estas são bastante comuns e você pode vê-las em aplicativos que 
funcionam em ambientesde produção, por exemplo, no site do New York Times (NYT). 
Uma vez que você esteja familiarizado com a ideia de que o MongoDB não pode resolver 
todos os seus problemas, você achará que, para alguns deles, o MongoDB é exato, com 
todas as conexões e as análises de dados na web (como exemplo, imagine o Analytics 
da Google, on-line, ou seja, em tempo real para o seu site) e com o uso da arquitetura e 
estruturas de dados complexos (postagens de blog e comentários, por exemplo).
Um conceito que coloca muita atenção no MongoDB está no fato de que ele sempre 
desenvolve mais de uma cópia do banco de dados. Em caso de falha, o banco de dados 
pode ser restaurado a partir dos servidores. Dada a proposta de ser o mais rápido 
10
UNIDADE I │ FUNDAmENtos Do moNgoDB
possível, o MongoDB usa alguns atalhos que dificultam a recuperação quando ocorre 
um bloqueio. Lembre-se de que o MongoDB não é um servidor ideal para qualquer 
coisa. No entanto, para cumprir uma variedade de propósitos, pode ser uma ferramenta 
incrível para implementar uma solução.
O site MongoDB contém downloads para Linux, Mac OS, Windows e Solaris. Não é 
necessário se preocupar em imprimir seus dados para colocá-los em uma tabela, basta 
coletá-los e enviá-los para o MongoDB para manipulá-lo. Em seguida, vamos a um 
exemplo do mundo real. Em uma determinada ação, pretendemos salvar um conjunto 
de resultados de pesquisa do eBay. Pode haver qualquer resultado (até cem) e foi 
necessário pensar uma maneira fácil de associar esses resultados aos usuários do seu 
banco de dados.
Se estivesse usando MySQL, os passos que iríamos seguir seriam: 
1. criar uma tabela para guardar os dados;
2. desenvolver o código para guardar seus resultados e, posteriormente, 
implementar outros códigos, adicionar e compilar tudo novamente. 
Nesse exemplo, de aplicação comum sendo normal os desenvolvedores se depararem 
com ele. No geral, simplesmente seguimos em frente para decidir a problemática. 
Mas, fazendo o uso do MongoDB o resultado foi satisfatório e ocorreu com apenas 
algumas diferenças se tratando de linhas de códigos.
Especificamente, foi adicionada a linha de código a seguir:
 » request[‘ebay_results’] = ebay_results_array
 » collection.save(request)
Acima no exemplo, o request é o documento, ebay_results é a chave e ebay_result_
array contém os resultados do eBay. 
A segunda linha quer dizer que salva as alterações. Um detalhe é que, no momento em 
que esse documento for acessado futuramente, terá os resultados do eBay da mesma 
forma do formato anterior. E pasmem! Não foi preciso fazer o uso de nenhum SQL. 
Sequer foi necessário fazer nenhuma conversão, nem criar tabela nova ou implementar 
código “extraterrestre” – o MongoDB simplesmente pegou. 
11
Fundamentos do mongodB │ unIdade I
Ausência de suporte inato a transações
Os desenvolvedores do MongoDB tomaram uma decisão importante: o banco de dados 
não inclui a semântica para os negócios (o elemento que oferece garantias sobre a 
coerência e o armazenamento de informações). Esta é uma compensação sólida com 
base no alvo do MongoDB ser simples, rápido e escalável. Depois que esses recursos 
pesados são deixados de lado, é mais fácil escalar horizontalmente.
Em um RDBMS tradicional, o desempenho do software é baseado nas características do 
computador: quanto maior e mais poderoso ele for, melhor o rendimento do RDBMS. 
Esta operação consiste em escalar verticalmente, mas pode levar até certo ponto. Com 
a escalada horizontal, em vez de ter um computador enorme, terá vários computadores 
menos potentes. Historicamente, os clusters foram excelentes para os criados como 
aquele que percebeu a carga oscilante nos lugares, no entanto, os bancos de dados 
foram sempre um problema devido às limitações de seus projetos internos.
Essa ausência de suporte forma uma falta de desempenho do banco de dados. No 
entanto, muitas pessoas esquecem quais dos tipos de tabelas mais populares no MySQL 
(MYISAM, que, por acaso, também é o valor padrão) que também não suportam 
transações. Esse fato não impediu o MySQL de se transformar no banco de dados 
de código aberto dominador durante muito mais do que uma década. Uma vez que é 
realizada pela maioria das opções quando desenvolvemos soluções, o uso do MongoDB 
será uma questão de preferência pessoal e de avaliação se a relação custo-benefício se 
adaptar ao seu projeto.
JSon e mongodB
JSON (Java Script Object Note) é mais do que uma excelente maneira de alterar dados. 
É também a melhor maneira de armazená-los. Um RDBMS é muito estruturado, 
com várias tabelas que armazenam tudo individualmente. MongoDB, por outro lado, 
armazena tudo em um documento único. É assim que o JSON neste aspecto oferece uma 
maneira sofisticada e expressiva de armazenar dados. Além disso, o JSON efetivamente 
descreve todo o conteúdo de um determinado documento, de modo que não precise 
especificar previamente a estrutura dele. O JSON é privado de esquemas (schemaless, 
em outras palavras, não exige um esquema), uma vez que os documentos podem ser 
atualizados individualmente ou alterados independentemente de qualquer outro. Como 
bônus, o JSON também oferece excelente desempenho, mantendo todos os dados como 
uma lista em um só lugar.
12
UNIDADE I │ FUNDAmENtos Do moNgoDB
MongoDB, de fato, não usa o JSON para armazenar dados. Em vez disso, ele usa um 
formato de dados aberto chamado BSON – que é a abreviatura de JSON binário, 
desenvolvido pela equipe MongoDB. Na maioria das vezes, usar BSON no lugar de 
JSON não mudará a maneira como você irá trabalhar com seus dados. O BSON torna 
o MongoDB ainda mais rápido, tornando muito mais fácil processar um computador e 
realizar pesquisas nos documentos.
O BSON também adiciona alguns recursos que não estão disponíveis no padrão JSON, 
incluindo a capacidade de adicionar tipos para o processamento de dados binários. 
A especificação JSON original pode ser encontrada na RFC 4627 e foi escrita por Douglas 
Crockford. O JSON permite que estruturas de dados complexas sejam representadas 
em um texto de formato simples, legível para humanos, que, em geral, é considerado 
muito mais fácil de ler do que o XML. 
Como o XML, o JSON foi projetado como uma maneira de trocar dados entre o cliente 
da web (por exemplo, o navegador) e os aplicativos da web. Quando se combina com o 
modo de seleção para o qual o JSON pode descrever objetos, sua simplicidade faz com 
que ele o torne a opção de formato preferencial na visão dos desenvolvedores.
Você pode estar se perguntando: O que está querendo dizer com dados complexos? 
Historicamente, os dados mudavam por meio do formato CVS (valores separados por 
vírgulas). O CSV é um formato de texto simples, em que as linhas são separadas por um 
caractere de quebra de linha e campos com vírgula. Por exemplo, um CSV classificado 
pode parecer semelhante:
 » Membrey, Peter, +852 1234 5678
 » Thielen, Wouter, +81 1234 5678
Uma pessoa pode observar esses dados e rapidamente perceber quais as informações 
que ele comunica. Ou talvez não: o número na terceira coluna é um número de telefone 
ou de um fax? O número de um sinal sonoro pode ser incluído.
Para evitar essa ambiguidade, os arquivos CSV geralmente possuem um campo de 
página de título, no qual a primeira linha define o que contém o arquivo. A seguinte 
passagem explica um pouco o exemplo anterior:
 » Lastname, Firstname, Phone Number
 » Membrey, Peter, +852 1234 5678
 » Thielen, Wouter, +81 1234 5678
13
Fundamentos do mongodB │ unIdade I
Agora, nós imaginamos que algumas pessoas no arquivo CSV têm mais de um número 
de telefone. Então, podemos adicionar outro campo para um número de telefone 
comercial, no entanto, isto será um novo problema se for necessário informar alguns 
números de telefone comercial. E haverá problemas também se for necessário adicionar 
alguns endereços de e-mail. A maioria das pessoas tem mais de um, e essas instruções 
não podem ser definidas em geral de forma clara nouso particular ou profissional. 
De repente, o CSV começa a mostrar suas limitações. Os arquivos CSV são apenas 
adequados para armazenar dados simples e não tem valores repetidos. Da mesma 
forma, não é incomum que alguns arquivos CSV estejam disponíveis, cada um com 
informações separadas. Esses arquivos então combinam (geralmente em um RDBMS) 
para criar uma imagem geral. Como exemplo, uma grande empresa de vendas no 
varejo pode receber dados de vendas sob a forma de arquivos CSV de cada uma de suas 
lojas no final de cada dia. Esses arquivos devem ser combinados antes que a empresa 
possa ver sua versão em um determinado dia. Este processo não é exatamente direto e, 
sem dúvida, o potencial de um erro ocorrer aumentará à medida que a quantidade de 
arquivos necessários aumenta.
Em geral, XML resolve esse problema. O XML é altamente extensível. Ao invés de definir 
um formato de dados específico, o XML define a forma de especificar um formato de 
dados. Isso pode ser útil quando for necessário trocar dados complexos e altamente 
estruturados. No entanto, para uma simples troca de dados, com frequência, isso gerará 
muito trabalho. Com efeito, esta cena deu origem à frase “XML hell” (XML do Inferno).
O JSON permite uma troca de dados interessante. De modo diferente do CVS, ele 
pode armazenar conteúdo estruturado, porém, diferentemente do XML, o JSON faz o 
conteúdo ser fácil de entender e simples de usar. Vamos retornar ao exemplo anterior, 
mas desta vez, usaremos JSON no lugar de CSV:
{
“firstname”:”Peter”, 
“lastname”:”Membrey”,
“phone_numbers”:[
“+852 1234 5678”,
“+44 1234 565 555”
]
}
14
UNIDADE I │ FUNDAmENtos Do moNgoDB
Nesta versão do exemplo, cada objeto de JSON (ou o documento) contém toda a 
informação necessária para que se possa entendê-la. Se você observar phone_numbers, 
verá que contém uma lista de números diferentes. Esta lista pode ser tão longa quanto 
necessária. Além disso, pode ser mais específica quanto ao tipo do número registrado, 
como no seguinte exemplo:
{ “firstname”:”Peter”,
 “lastname”:”Membrey”,
 “numbers”:[
{
 “phone”:”+85212345678”
},
{
“fax”:”+441234565555”
}
]
}
Esta versão do exemplo contém melhorias em alguns aspectos. Agora podemos 
ver claramente sobre o que cada informação se trata. O JSON é extremamente 
expressivo e embora seja geralmente bastante fácil codificá-lo manualmente, o JSON 
é gerado automaticamente pelo software. Por exemplo, Python inclui um módulo que 
automaticamente converte objetos de Python para JSON. Apoiado e usado em múltiplas 
plataformas, o JSON é uma escolha ideal para trocar dados. 
Ao acrescentar itens como a lista de números de telefone, cria-se o que chamamos 
de documento embutido (embedded document). Isto acontece sempre quando 
em um conteúdo complexo é acrescentado, por exemplo, uma lista (ou uma tabela, 
termo preferido pelo JSON). Por exemplo, o documento “pessoa” pode ter múltiplos 
documentos “Address” embutidos. Semelhantemente, um documento “Invoice” pode 
ter múltiplos documentos de “LineItem” integrados. É claro que o documento “Address” 
construído no documento “pessoa” também pode conter o seu próprio documento 
construído, incluindo, por exemplo, números de telefone.
15
Fundamentos do mongodB │ unIdade I
O MongoDB não é um banco de dados de tamanho único, que possui aqueles 
formatos que é “bom para tudo”, mas possui um compromisso no que diz respeito aos 
custos-benefícios, a fim de atender aos objetivos da aplicação. Normalmente, é chamado 
de design do esquema (schema design). Pode parecer estranho referir-se ao MongoDB 
como design do esquema quando o MongoDB se considera um banco de dados sem 
esquemas. 
o banco de dados em qualquer lugar
O MongoDB está desenvolvido na linguagem de programação C++, o que faz com 
que seja possível executar a aplicação praticamente em qualquer lugar. Atualmente, 
os binários podem ser baixados do site do MongoDB e estão disponíveis para Linux, 
Mac OS, Windows e Solaris. Diferente das outras ferramentas, o MongDB pode ser 
desenvolvido até por você mesmo, é só baixar o código-fonte e fazer seu próprio 
MongoDB, embora seja recomendável utilizar os binários disponibilizados sempre 
que for possível. Todos os binários estão disponíveis tanto para versões 32 bits quanto 
para 64 bits.
Os requisitos modestos do MongoDB permitem que ele seja executado em servidores 
altamente capacitados ou em máquinas virtuais, e até mesmo em aplicações baseadas 
na nuvem. Ao manter a simplicidade e focar na velocidade e na eficiência, o MongoDB 
proporciona um desempenho sólido, independentemente do local em que você optar 
por implantá-lo.
16
CAPítulo 2
Entendendo as partes do mongodB
Não há requisitos para se trabalhar incialmente com o MongoDB, ou seja, você não 
precisa ser um especialista para dar o pontapé inicial. Abaixo vamos entender sobre 
mais características do MongoDB e termologia padrão dos bancos de dados.
gerando ou criando uma chave
Um documento representa o storage (armazenamento) do MongoDB. Em um RDBMS, 
esta unidade é chamada de linha. No entanto, os documentos são muito mais do que 
linhas, porque eles possuem a capacidade de guardar informações difíceis, como por 
exemplo: listas, dicionários e até listas de dicionário. Ao contrário de um banco de 
dados tradicional, em que uma linha é corrigida, um documento no MongoDB pode 
ser composto de qualquer número de chaves e valores. Em última análise, uma chave 
é apenas um rótulo; é equivalente ao nome que se daria a uma coluna em um RDBMS. 
Uma chave é usada para se referir a partes dos dados no documento.
Em um banco de dados relacional, sempre haverá uma forma de identificar apenas 
um registro, caso contrário, será impossível de se referir a uma linha específica. 
Assim, é necessário incluir um campo que armazene um valor exclusivo (chave 
primária) ou um conjunto de campos que só podem identificar a linha especificada 
(chave primária composta).
O MongoDB sempre solicita que cada documento tenha um identificador exclusivo, 
seguindo a mesma lógica e pelo mesmo motivo. Esse identificador no MongoDB é 
chamado de “_id”. Se você não especificar um valor para este campo, ele gerará um 
valor exclusivo (único). Mesmo vivendo em um mundo sólido com relação aos bancos 
de dados RDBMS, não há consenso sobre o uso de uma chave única fornecida pelo 
banco de dados ou em sua geração. Recentemente, tornou-se mais popular permitir 
que o banco de dados crie a chave para você.
A razão é que as pessoas têm o mau hábito de mudar os números exclusivos criados por 
eles, como os números das placas de veículos. Por exemplo, a Inglaterra implantou um 
novo modelo de número de placas de automóveis que é totalmente diferente do sistema 
antigo. O fato é que o MongoDB pode lidar perfeitamente com esse tipo de mudança. 
No geral, seguindo este mesmo exemplo, é necessário que você veja com muita atenção 
se você usou a placa do veículo como a chave primária.
17
Fundamentos do mongodB │ unIdade I
Inicialmente, uma grande parte dos desenvolvedores que usavam o MongoDB tinha 
suas preferências em criar suas próprias chaves únicas, assumindo a responsabilidade 
de garantir que o número permanecesse único. Hoje em dia, o consenso geral parece 
indicar o uso do valor do ID padrão que o MongoDB cria para você. No entanto, como no 
caso do trabalho com bases de dados RDBMS, a abordagem escolhida é principalmente 
reduzida às preferências pessoais. No geral, é interessante usar um valor fornecido 
pelo banco de dados porque mostra que temos a certeza que a chave será única e 
independente de todo o resto. Mas, temos os casos particulares em que as pessoas ainda 
preferem usar suas chaves.
No final, você tem o poder de decidir o que é mais interessante e apropriado para o seu 
desenvolvimento. Se você tiver certeza de que sua chave será única (e deve permanecer 
inalterada), você deve se sentir confortável usando isso. Se você não tem certeza da 
singularidade da sua chave ou não querse preocupar, você pode simplesmente usar a 
chave padrão fornecida pelo MongoDB.
usando chaves e valores
Os documentos são compostos de chaves e valores. Vamos dar outra olhada no exemplo 
discutido anteriormente neste capítulo:
{ 
“firstname”:”Peter”,
“lastname”:”Membrey”,
“phone_numbers”:[
“+852 1234 5678”,
“+44 1234 565 555”
]
}
Chaves e valores sempre são exibidos em pares. De uma maneira diferente de um 
RDBMS, em que um valor deve ter qualquer campo, apesar de ser o mesmo que NULL 
(então, até certo ponto, paradoxal, esse valor significa desconhecido), MongoDB não 
exige que um documento tenha um valor individual. Por exemplo, se você não conhece 
o número de telefone de uma pessoa em sua lista, basta deixá-lo de fora. Uma analogia 
popular para este tipo de situação ocorre com o cartão de visita. Se você tiver um número 
18
UNIDADE I │ FUNDAmENtos Do moNgoDB
de telefone fixo, normalmente será incluído no seu formulário de visita. No entanto, se 
não tiver um, você não vai escrever “Número de telefone fixo: nenhum”. Ao invés disso, 
você simplesmente deixará de inserir essa informação. Se a mesma chave/valor não 
estiver incluída em um documento do MongoDB, assume-se que não existe.
implementando coleções
As coleções, de certa forma, são semelhantes às tabelas, mas são muito menos rígidas. 
Uma coleção é muito semelhante a uma caixa com um rótulo. Talvez você tenha uma 
caixa em casa com um rótulo que diga “DVD”, na qual você deve colocar seus DVDs. 
Isso faz sentido, mas nada impede que você coloque CDs ou mesmo que conserte esta 
caixa. Em um RDBMS, as tabelas são estritamente definidas e você pode inserir apenas 
certos elementos nelas. No MongoDB, uma coleção é simplesmente um conjunto de 
objetos (itens) semelhantes. Os itens não precisam necessariamente ser semelhantes 
(o MongoDB é inerentemente flexível). No entanto, depois de conhecer a indexação e 
começar a ver consultas mais sofisticadas, logo você perceberá os benefícios de colocar 
itens semelhantes em uma coleção.
Embora seja possível misturar diferentes elementos em uma coleção, não há muita 
necessidade de fazer isso. Se a coleção fosse chamada de mídia, então todos os DVDs, 
CDs e fitas estariam em um determinado local correto. Afinal, esses elementos têm 
características comuns, como o nome de um artista, data de lançamento e conteúdo. 
Em outras palavras, o fato de certos documentos serem armazenados na mesma 
coleção depende muito da sua aplicação. E quanto ao desempenho, ter diferentes 
coleções não faz o sistema mais lento do que ter apenas uma. Lembre-se de que 
MongoDB busca facilitar seus processos, simplificar sua vida, então você tem que 
fazer o que deve ser melhor.
Finalmente, as coleções são criadas efetivamente diante de sua demanda. 
Especificamente, uma coleção será criada na sua primeira tentativa de salvar um 
documento que a referenciá-la. Isso significa que é possível criá-las para uma demanda 
(não é necessário fazê-lo). Uma vez que o MongoDB também permite que você crie 
índices e execute outros comandos de nível de banco de dados dinamicamente, 
você pode aproveitar esse comportamento para criar algumas aplicações bastante 
dinâmicas.
Entendendo os bancos de dados
Talvez a maneira mais simples de pensar em um banco de dados no MongoDB é 
imaginá-lo como uma coleção de coleções. Exatamente, coleção de coleções!
19
Fundamentos do mongodB │ unIdade I
Os bancos de dados podem ser criados mediante solicitação. Isso significa que é fácil 
criar um banco de dados para cada cliente - o código da sua aplicação também pode ser 
feito para você. Isso também pode ser feito com bancos de dados que não são MongoDB. 
No entanto, criar bancos de dados dessa forma com o MongoDB é um processo bastante 
natural. Apesar do que foi dito, somente porque você pode criar um banco de dados 
dessa maneira não significa que você vá ou que você tem que fazê-lo. No entanto, você 
terá essa habilidade se quiser usá-la.
20
CAPítulo 3
Examinando a lista de recursos
Até agora vimos o que é o MongoDB e o que ele pode oferecer, agora iremos conhecer a 
lista de recursos que ele proporciona. A lista completa pode ser visualizada no próprio 
site <www.mongodb.com>. Sempre que possível acesse o site porque os desenvolvedores 
estão em constante atualização, porém os recursos estão bem próximos ao comum. 
Ultimamente, se tem feito uma grande evolução na parte da interface do MongoDB. 
A lista de recursos neste capítulo inclui muitas atividades que ocorrem internamente, 
mas fique tranquilo! Não precisa ter medo e não precisa estar familiarizado com todos 
os recursos listados para poder usar o MongoDB. 
usando armazenamento orientado a 
documentos (BSon)
O BSON é um padrão aberto e suas características podem ser encontradas no 
próprio site <http://bsonspec.org>. Quando a comunidade ouve falar que BSON é 
um formato binário do JSON eles esperam que ocupe muito menos espaço do que 
o formato JSON baseado em texto. No entanto, isso não é necessariamente o que 
realmente acontece, existem várias situações em que o BSON ocupará mais espaço 
do que o equivalente JSON.
E afinal, você deve estar se perguntando: por que BSON deve ser usado? Bom, o 
CouchDB (outro banco de dados eficiente e orientado a documentos) usa o JSON puro 
e é razoável perguntar se vale a pena ter o trabalho de converter documentos BSON em 
JSON e vice-versa.
Antes de tudo, em primeiro lugar, nós devemos lembrar que o MongoDB foi criado 
para ser rápido e não tão eficiente como ter espaço. Isso não significa que o MongoDB 
desperdiça espaço (não), no entanto, um overhead para arquivar um documento é 
perfeitamente aceitável se é assim que é mais rápido buscar dados (o que é verdade). 
Em suma, o BSON é muito mais fácil de transmitir (em outras palavras, para ser 
analisado e indexado rapidamente). Embora o BSON requeira um pouco mais de 
espaço do que o JSON, é improvável que este espaço extra seja um problema, já que 
os discos têm um baixo custo e o MongoDB pode escalar usando vários computadores. 
A vantagem de custo, neste caso, é bastante razoável: um pouco mais de espaço em 
disco é trocado para melhorar o desempenho e a indexação da consulta.
21
Fundamentos do mongodB │ unIdade I
Ao usar o BSON, a segunda grande vantagem é que é fácil e rápido convertê-lo para 
um formato de dados nativo de uma linguagem de programação. Se os dados foram 
armazenados em JSON puro, é necessário realizar uma conversão relativamente alta. 
Existem drivers MongoDB para um grande número de linguagens de programação 
(como PHP, Python, Ruby, C ++, C, e C #), e cada um deles funciona de forma muito 
diferente. Quando usamos um formato binário simples, as estruturas de dados nativas 
tendem a ser usadas rapidamente para cada idioma, sem necessariamente inicializar o 
JSON. Isso torna o código mais simples e rápido, de acordo com os objetivos definidos 
para o MongoDB.
O BSON também disponibiliza algumas extensões para o JSON. Por exemplo, permite 
armazenar dados binários e incorporar um tipo específico de dado. Desta forma, 
enquanto o BSON pode armazenar qualquer documento JSON, um documento BSON 
válido não pode ser um JSON válido. Porém, isso não importa, pois cada idioma possui 
seu próprio driver que converte dados de e para BSON, sem a necessidade de usar 
JSON como um idioma intermediário.
No final das contas, não é muito provável que o BSON seja um fator importante 
nas instruções de uso do MongoDB. Com todas as ótimas ferramentas, o MongoDB 
permanecerá em silêncio em um segundo nível e fará o que precisa ser feito. Além de 
possivelmente usar uma ferramenta gráfica para analisar seus dados, em geral, você 
trabalhará com seu idioma nativo e deixará o driver se preocupar com a persistência no 
MongoDB.
Suportando queries dinâmicas
O apoio do MongoDB para consultas dinâmicas visa que você possa executar uma 
consulta sem tê-la planejado antecipadamente. É semelhante a ser capaz de executar 
consultas SQL em um RDBMS. Mas você deveestar se perguntando: Por que isto está 
listado como um recurso? Certamente pelo fato de que qualquer banco de dados suporta 
consultas dinâmicas, correto?
Nem sempre! Vejamos, o CouchDB (que é considerado o maior “concorrente” do 
MongoDB) não suporta consultas dinâmicas. Isso ocorre porque o CouchDB apareceu 
com uma maneira completamente nova de pensar os dados. Um RDBMS tradicional 
possui dados estáticos e consultas dinâmicas. Isso significa que a estrutura de dados 
é definida com antecedência: os gráficos devem ser definidos e cada linha deve ser 
adaptada a essa estrutura. Uma vez que a base de dados conhece antecipadamente a 
forma como os dados são estruturados, pode-se fazer algumas suposições e otimizações, 
o que permite que você faça consultas dinâmicas e rápidas.
22
UNIDADE I │ FUNDAmENtos Do moNgoDB
O CouchDB modificou este conceito. Sendo um banco de dados orientado para 
documentos, o CouchDB não possui esquemas, portanto, os dados são dinâmicos. 
Enquanto isso, a nova ideia, neste caso, é que as consultas sejam estáticas. Em outras 
palavras, eles devem ser previamente definidos, antes de serem usados.
Tudo o que pode parecer não é tão ruim, já que muitas questões podem ser facilmente 
definidas anteriormente. Por exemplo, um sistema que permite que você procure um 
livro provavelmente deixará a busca com base no ISBN. No CouchDB, você precisa 
criar uma referência ou índice que crie uma lista de todos os ISBNs para todos os 
documentos. À medida que você escreve um ISBN, a consulta será muito rápida, pois 
você não precisará realmente procurar dados. Sempre que novos dados são adicionados 
ao sistema, o CouchDB atualizará sua velocidade automaticamente.
Tecnicamente, uma consulta pode ser realizada no CouchDB sem a qual é desenvolvido 
um índice. Neste caso, no entanto, o CouchDB terá que criar a referência ou índice 
antes de poder seguir com sua consulta. Isso não será um problema se houver apenas 
uma centena de livros. No entanto, se você armazenar centenas de milhares de livros, 
o desempenho será reduzido, pois cada consulta irá gerar novamente o índice (e 
novamente). Por esse motivo, a equipe do CouchDB não recomenda o uso de consultas 
dinâmicas - em outras palavras, consultas que não foram predefinidas no ambiente de 
produção.
O CouchDB também permite que você crie suas próprias consultas como funções map 
e reduce. Se isso parecer algo que requer muito esforço, então você estará em boa 
companhia, o CouchDB tem uma curva de aprendizado, de certa forma, difícil. Para que 
possamos estar sozinhos com o CouchDB, um programador experiente provavelmente 
poderá compreendê-lo rapidamente. Para a maioria das pessoas, no entanto, a curva de 
aprendizado é difícil.
indexando seus documentos
O MongoDB possui em seu acervo um extenso suporte para indexar seus documentos, 
um recurso que será muito prático ao lidar com dezenas de milhares de documentos. 
Sem um índice, o MongoDB terá que examinar cada documento, um por vez, para ver 
se há algo que você deseja ver. É como se você pedisse um livro para um bibliotecário e 
assistisse enquanto ele atravessa a biblioteca inteira olhando para todos os livros. Com 
um sistema de indexação (normalmente as bibliotecas usam o método de classificação 
decimal de Dewey), o bibliotecário poderá encontrar a área em que o livro é guardado 
e, rapidamente, poderá determinar se ele está lá.
23
Fundamentos do mongodB │ unIdade I
Ao contrário de um livro de biblioteca, todos os documentos no MongoDB são 
indexados automaticamente usando a chave “_id”. Esta chave é avaliada como caso 
especial, uma vez que não é deletada Um índice garante que cada valor deve ser único. 
Uma das vantagens desta chave é que podemos ter certeza de que cada documento será 
identificado unicamente – algo que um RDBMS não possui essa garantia.
Ao criar seus índices, é possível decidir se você deseja que eles garantam a unicidade. 
Se você deseja criar um único índice, pode informar ao MongoDB que descarte todas as 
duplicações. Isso pode ou não ser o que você quer, então pense com atenção antes de 
usar esta opção, pois pode haver metade dos seus dados acidentalmente apagados. Por 
padrão, um erro voltará atrás se for feita uma tentativa para criar um único índice com 
uma chave com valores duplicados.
Existem várias oportunidades nas quais você pode querer criar um índice que permita 
duplicação. Por exemplo, se seu aplicativo fizer perguntas ao usuário de acordo com 
o seu último nome, o último nome faz sentido ser um índice. É claro que não se pode 
garantir que cada último nome seja único. Em qualquer banco de dados de tamanho 
razoável, é quase certo que haverá duplicações.
Contudo as capacidades de indexação do MongoDB não terminam por aqui. Ele também 
pode criar índices em documentos embutidos (embedded documents). Por exemplo, 
se diversas localidades forem armazenadas na chave endereço, você poderá criar um 
índice com o CEP. Isso significa que será possível recuperar um documento diante de 
qualquer CEP – e isso poderá ser feito rápido.
O MongoDB vai um pouco além ao permitir o uso de índices compostos. Em um índice 
composto, duas ou mais chaves são necessárias para a criação de um determinado 
índice. Exemplo: Ao criar um índice que combine as tags “lastname” e “firstname” 
uma pesquisa pelo nome completo será muito rápida, pois o MongoDB poderá isolar 
rapidamente o lastname e, em seguida, de maneira igualmente rápida, isolar o 
firstname. O MongoDB cuida de tudo para você no que diz respeito à indexação.
gerando perfis de queries
A ferramenta pronta para a geração de perfil (profiling) permite que você veja como 
o MongoDB descobre quais documentos devem ser retornados. Isso é útil porque, em 
muitos casos, uma consulta pode ser facilmente aprimorada simplesmente adicionando 
um índice. Se você tem uma consulta complicada e não tem certeza de por que está 
funcionando tão devagar, o gerador de perfis de queries do MongoDB poderá oferecer 
informações extremamente valiosas.
24
UNIDADE I │ FUNDAmENtos Do moNgoDB
Atualizando informações in-place
Quando uma linha é atualizada de um banco de dados (ou, no caso do MongoDB, 
um documento), ele possui algumas opções sobre como fazer essa atualização. 
Muitos bancos de dados optam pela abordagem MVCC (Multi-Version Concurrency 
Control), que faz com que usuários distintos vejam versões diferentes dos dados. 
É uma abordagem interessante e útil, por assegurar que os dados não serão parcialmente 
editados ou ajustados por outro programa durante uma determinada transação.
A desvantagem dessa abordagem reside no fato de que o banco de dados terá que 
verificar várias cópias, ou seja, fazer o controle de tudo isso. Exemplo: o CouchDB 
oferece um controle bastante robusto das versões, mas isso tem o custo de tornar os 
dados armazenados na sua totalidade. Por outro lado, tendo em vista que este processo 
garante que esses sejam armazenados de forma robusta, a complexidade aumenta e o 
desempenho é reduzido. É aquela velha história, ganho de um lado e perco do outro!
O MongoDB, por outro lado, atualiza a informação no local (in-place). Isso significa que 
o MongoDB pode atualizar os dados no local em que será encontrado. Normalmente, 
isso significa que você não precisará alocar espaço adicional e que os índices podem 
permanecer inalterados.
Outra vantagem deste método é que o MongoDB executa “lazy writes” (escritas 
preguiçosas). Ler e escrever na memória é muito rápido, mas escrever em disco é o 
oposto da velocidade, muito lento. Isso significa que é necessário limitar a leitura e a 
escrita no disco, tanto quanto possível. Isso não é necessário no CouchDB porque este 
programa garante que qualquer documento deve ser gravado rapidamente no disco. 
Apesar de garantir essa abordagem, os dados devem ser gravados de forma segura no 
disco, também causa impactos significativos em relação ao desempenho.
O MongoDB grava em disco somente quando for necessário, o que normalmente 
ocorreaproximadamente a cada segundo. Isso significa que se um valor estiver sendo 
atualizado várias vezes por segundo – um cenário que não será incomum se um valor 
estiver sendo usado como contador de páginas ou para estatísticas em tempo real – 
então esse valor será gravado somente uma vez, em vez de milhares de vezes, conforme 
seria exigido pelo CouchDB.
A abordagem torna o MongoDB muito mais rápido, mas, novamente, há uma 
contrapartida. O CouchDB pode ser mais lento, mas ele garante que os dados serão 
armazenados de forma segura no disco. O MongoDB não oferece esse tipo de garantia, 
e é por isso que um RDBMS tradicional, provavelmente, será uma solução melhor para 
gerenciar dados críticos como, por exemplo, de cobrança ou de contabilidade.
25
Fundamentos do mongodB │ unIdade I
Armazenando dados binários
O GridFS é a solução do MongoDB para armazenar dados binários no banco de dados. 
O BSON suporta salvar até 4 MB de dados binários em um documento e isso deve ser 
mais que suficiente para atender às suas necessidades. Por exemplo, se você quiser 
armazenar uma imagem de perfil ou um clipe de áudio, então 4 MB representa mais 
espaço do que o necessário. Por outro lado, se você quiser armazenar um trailer de 
filme, clipes e áudios de alta qualidade ou até mesmo arquivos que tenham centenas de 
megabytes de tamanho, o MongoDB também tem uma solução para esses casos.
O GridFS funciona armazenando informações sobre o arquivo (chamadas de metadados) 
na coleção files. Os dados propriamente ditos são separados em partes chamadas 
chunks (porções), que são armazenadas na coleção chunks. Essa abordagem faz com 
que o armazenamento de dados seja fácil e escalável. Também torna as operações 
envolvendo intervalos (por exemplo, obter partes específicas de um arquivo) muito 
mais simples de usar.
Falando de modo geral, você deve usar o GridFS por meio do driver do MongoDB para 
a sua linguagem de programação, portanto é improvável que você vá precisar sujar as 
mãos com um nível tão baixo de programação. Com tudo mais no MongoDB, o GridFS 
foi projetado visando tanto à velocidade quanto à escalabilidade. Isso quer dizer que 
podemos estar certos de que ele estará à altura da tarefa se quisermos trabalhar com 
arquivos grandes de dados.
replicando dados
Quando falamos sobre os princípios norteadores por trás do MongoDB, mencionamos 
que os bancos de dados RDBMS oferecem determinadas garantias para o 
armazenamento de dados que não estão disponíveis no MongoDB. Essas garantias não 
foram implementadas por vários motivos. Em primeiro lugar, esses recursos deixariam 
o banco de dados lento. Em segundo, eles iriam aumentar enormemente a complexidade 
do programa. Em terceiro, havia uma percepção de que a falha mais comum em um 
servidor seria de hardware, o que deixaria os dados inutilizáveis, de qualquer maneira, 
mesmo que eles fossem salvos em disco de forma segura.
É claro que nada disso significa que a segurança dos dados não seja importante. 
O MongoDB não teria muita utilidade se você não pudesse contar com o fato de ser capaz 
de acessar os dados quando precisar deles. Inicialmente, o MongoDB oferecia uma rede 
de proteção com um recurso chamado replicação master-slave (mestre-escravo), em 
que somente um banco de dados estava ativo para escrita em um determinado instante 
26
UNIDADE I │ FUNDAmENtos Do moNgoDB
– uma abordagem que também é razoavelmente comum no mundo RDBMS. De lá para 
cá, esse recurso foi substituído por conjuntos de réplicas (replica sets) e a replicação 
master-slave básica se tornou obsoleta e não deverá mais ser utilizada.
Os conjuntos de réplicas têm um servidor principal (semelhante ao master), que 
cuida de todas as solicitações de escrita dos clientes. Como há somente um servidor 
principal em um dado conjunto, pode-se garantir que todas as escritas serão tratadas 
adequadamente. Quando uma escrita ocorrer, ela será registrada no oplog (operation 
log)1 do servidor principal. Oplog é uma coleção exclusiva que mantém um registro 
contínuo de todas as operações que modificam os dados armazenados em seus bancos 
de dados.
O oplog é replicado pelos servidores secundários (podem haver vários deles) e usado 
para que eles se atualizem em relação ao master. Caso o master falhe em determinado 
instante, um dos servidores secundários se tornará o servidor principal e assumirá a 
responsabilidade de cuidar das solicitações de escrita dos clientes.
implementando o sharding
Para as pessoas envolvidas em implantação de sistemas de larga escala, é provável que 
o autosharding se prove ser um dos recursos mais significativos e mais utilizados do 
MongoDB.
Em um cenário com autosharding, o MongoDB cuidará de todas as separações 
e recombinações de dados para você. Ele garantirá que os dados serão enviados ao 
servidor correto e que as queries serão executadas e combinadas da maneira mais 
eficiente possível. Com efeito, do ponto de vista de um desenvolvedor, não há nenhuma 
diferença entre conversar com um banco de dados MongoDB com uma centena de 
shards e conversar com um único servidor MongoDB.
Nesse meio tempo, se você estiver começando a usar o MongoDB ou estiver 
desenvolvendo o seu primeiro site baseado nele, provavelmente descobrirá que uma 
única instância dele será suficiente para atender às suas necessidades. Se você acabar 
criando o próximo Facebook ou a próxima Amazon, ficará satisfeito por ter criado o seu 
site usando uma tecnologia que possa escalar de maneira tão irrestrita.
usando as funções map e reduce
Para muitas pessoas, ouvir o termo MapReduce provoca calafrios na espinha. No outro 
extremo, muitos defensores do RDBMS desdenham da complexidade das funções 
1 <https://docs.mongodb.com/manual/core/replica-set-oplog/>.
27
Fundamentos do mongodB │ unIdade I
map e reduce. Para algumas pessoas, essas funções são assustadoras, pois exigem 
uma maneira totalmente diferente de pensar na maneira de encontrar e ordenar os 
dados, e muitos programadores profissionais têm problemas em entender os conceitos 
subjacentes às funções map e reduce. Apesar do que foi dito, essas funções oferecem 
uma maneira extremamente eficaz de consultar dados. Com efeito, o CouchDB suporta 
somente essa abordagem, que é um dos motivos pelos quais ele tem uma curva de 
aprendizado tão difícil.
O MongoDB não exige que você use as funções map e reduce. De fato, o MongoDB 
depende de uma sintaxe simples de query, que é mais semelhante àquilo que vemos no 
MySQL. Entretanto o MongoDB disponibiliza essas funções para aqueles que quiserem 
usá-las. As funções map e reduce estão implementadas em JavaScript e executam no 
servidor. A função de map é encontrar todos os documentos que atendam determinados 
critérios. Esses resultados são então passados à função reduce, que processa os dados. 
A função reduce geralmente não retorna uma coleção de documentos. Ao invés disso, 
ela retorna um novo documento que contém as informações resultantes. Como regra 
geral, se você normalmente usar GROUP BY no SQL, então as funções map e reduce 
provavelmente serão as ferramentas adequadas para realizar a tarefa no MongoDB.
o framework de agregação do mongodB
O MapReduce é uma ferramenta bastante eficaz, porém tem uma desvantagem 
importante: ela não é fácil de usar. Muitos sistemas de bancos de dados são utilizados 
para gerar relatórios e os bancos de dados SQL em particular tornam essa tarefa bem 
simples. Se quiser agrupar resultados ou encontrar o valor máximo e a média, então 
será bem simples expressar essa ideia e obter o resultado que você estiver procurando. 
Infelizmente, não é tão simples fazer isso no MapReduce e você deverá fazer todas 
as conexões por conta própria. Com frequência, isso pode significar que uma tarefa 
simples será desnecessariamente desafiadora.
Em resposta a isso, a MongoDB Inc (anteriormente, 10gen) acrescentou o framework de 
agregação. Ele é baseado em pipelines, semelhante aos comandos de piping em shells 
Linux, e permite encadear partes individuaisde uma query para obter o resultado que 
você estiver procurando. Isso preserva os benefícios do design orientado a documentos 
do MongoDB, ao mesmo tempo que possibilita ter um bom desempenho.
28
unidAdE ii
fAzEndo A 
inStAlAção do 
mongodB
CAPítulo 1
qual sistema usar?
O MongoDB é um banco de dados multiplataforma e você poderá encontrar uma lista 
significativa de pacotes disponíveis para download em seu site <www.mongodb.com>. 
A variedade de versões disponíveis pode fazer com que seja difícil decidir qual é a versão 
correta. 
Na seção DOWNLOAD do site do MongoDB, você terá uma visão geral simples dos 
pacotes disponíveis para download. O primeiro ponto em que você deve prestar atenção 
é o sistema operacional em que o software do MongoDB será executado. Atualmente, há 
pacotes pré-compilados disponíveis para Windows, para diversas variantes do sistema 
operacional Linux, para Mac OS e para Solaris.
Você também deverá prestar atenção à versão do software do MongoDB: há versão para 
produção, versões anteriores e versões em desenvolvimento. A versão para produção 
(production) indica que essa é a versão estável mais recente sendo disponibilizada. 
Quando uma versão mais nova e normalmente melhorada ou aperfeiçoada é 
disponibilizada, a anterior mais estável e mais recente será disponibilizada como uma 
versão anterior (previous release). Essa designação significa que a versão é estável 
e confiável, porém, normalmente, conterá menos recursos disponíveis. Por fim, 
temos a versão de desenvolvimento (development release). Essa versão geralmente é 
referenciada como sendo instável. É uma versão que ainda está em desenvolvimento 
e contém várias alterações, inclusive novos recursos significativos. Embora ainda não 
tenha sido totalmente desenvolvida e testada, os desenvolvedores do MongoDB a 
disponibilizam para que o público experimente e possa usá-la. 
O MongoDB utiliza a abordagem de “versões de número ímpar para releases de 
desenvolvimento”. Em outras palavras, ao observar a segunda parte do número da 
versão (também chamada de número de release), podemos dizer se uma versão é de 
desenvolvimento ou se é uma versão estável. Se o segundo número for par, então o 
29
Fazendo a Instalação do MongodB │ UnIdade II
release será estável. Se o segundo número for ímpar, será um release instável ou de 
desenvolvimento. 
Vamos observar detalhadamente os três dígitos incluídos nas três partes A, B e C – de 
um número de versão.
 » A - é o primeiro número (ou o número mais à esquerda) -> representa a 
versão principal e muda somente quando há uma atualização completa 
da versão.
 » B - é o segundo número (ou o número do meio) -> representa o número 
do release e indica se uma versão é de desenvolvimento ou se é estável. 
Se o número for par, a versão será estável. Se for ímpar, a versão será 
instável e considerada como um release de desenvolvimento.
 » C - é o terceiro número (o número mais à direita) -> representa o número 
da revisão e é usado para correção de bugs e de problemas de segurança.
o mongodB no linux
Os sistemas operacionais baseados em Unix são opções extremamente populares 
atualmente para hospedar serviços, incluindo web services, serviços de e-mail e, 
é claro, serviços de bancos de dados. No Linux, ou popular Ubuntu, há duas maneiras 
de instalar: você pode instalar os pacotes automaticamente por meio dos chamados 
repositórios ou pode instalá-lo manualmente. As duas próximas seções descreverão 
ambas as opções.
instalando o mongodB por meio de repositórios
Os repositórios basicamente são diretórios on-line cheios de software. Todo pacote 
contém informações sobre o número da versão, os prerrequisitos e possíveis 
incompatibilidades. Essas informações serão úteis quando for necessário instalar um 
pacote de software que exija outro software a ser instalado antes, pois os prerrequisitos 
podem ser instalados ao mesmo tempo.
Os repositórios-padrões disponíveis para o Ubuntu (e para outras distribuições baseadas 
em Debian) contêm o MongoDB, mas podem ter versões desatualizadas do software. 
Sendo assim, vamos dizer ao apt-get (o software usado para instalar softwares a partir 
de repositórios) que olhe um repositório personalizado. Para isso, será necessário 
acrescentar a linha a seguir à sua lista de repositórios (/etc/apt/sources.Iist).
30
UNIDADE II │ FAzENDo A INstAlAção Do MoNgoDB
deb <http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen>.
Em seguida, importe a chave GPG pública do MongoDB Inc, usada para assinar os 
pacotes, garantindo a sua consistência. Isso pode ser feito por meio do comando 
apt-key:
$sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
Após ter feito esse procedimento, será preciso dizer ao apt-get que há novos repositórios, 
isso pode ser feito por meio do comando update do apt-get
$sudo apt-get update
Essa linha fez o aptitude tomar conhecimento de seu repositório adicionado 
manualmente. Isso significa que agora você pode dizer ao apt-get para instalar o 
software. Faça isso digitando o comando a seguir no shell:
$sudo apt-get install mongodb-org
Essa linha instala a versão atual estável (de produção) do MongoDB. Se você quiser 
instalar qualquer outra versão, será preciso especificar o número dela. Por exemplo, 
para instalar a versão atual instável (de desenvolvimento) do MongoDB, digite o 
comando a seguir no lugar do comando anterior:
$sudo apt-get install mongodb-org=3.2.0
Isso é tudo que é preciso fazer. A essa altura, o MongoDB terá sido instalado e estará 
(quase) pronto para ser usado!
instalando o mongodB manualmente
Considerando como é fácil instalá-lo automaticamente com o aptitude, você poderá 
estar se perguntando por que iria querer instalar o software manualmente. Para 
começar, nem todas as distribuições Linux usam apt-get. Com certeza, muitas delas 
o utilizam (incluindo pincipalmente aquelas que são baseadas no Debian Linux), mas 
algumas não o fazem. 
Além do mais, os pacotes disponibilizados permanecem como um trabalho em progresso, 
portanto, pode haver ocasiões em que as versões ainda não estejam disponíveis por 
meio dos repositórios. Também é possível que a versão do MongoDB que você queira 
usar não esteja incluída no repositório. Instalar o software manualmente também 
possibilita executar diversas versões do MongoDB ao mesmo tempo.
31
Fazendo a Instalação do MongodB │ UnIdade II
Você já decidiu qual versão gostaria de usar e fez seu download a partir do site <http://
mongodb.org/downloads> para o seu diretório Home. A seguir, você deve extrair o 
conteúdo do pacote usando o comando a seguir. O MongoDB já está pronto!
$ tar xzf mongodb-linux-x86_64-latest.tgz
instalando o mongodB no Windows
O Microsoft Windows também é uma opção popular para software de servidores, 
incluindo aqueles que disponibilizam serviços baseados em Internet. 
O Windows não tem uma aplicação de repositório como o apt-get, portanto será 
necessário fazer download e extrair o software a partir do site do MongoDB para 
executá-lo. Sim, a informação anterior está correta. Não é preciso passar por nenhum 
processo de instalação, instalar o software é simplesmente uma questão de fazer 
download do pacote, extrair o seu conteúdo e executar a aplicação propriamente dita. 
Por exemplo, suponha que você tenha decidido fazer download da versão estável mais 
recente do MongoDB para o seu servidor Windows 2012 de 64 bits. Comece extraindo o 
conteúdo do pacote (mongodb-win32-x86_64-x.y.x.zip) na raiz de seu drive C:\. Nesse 
ponto, tudo que você deve fazer é abrir um prompt de comandos usando Start > Run > 
cmd > OK (Iniciar > Executar > cmd > OK) e acessar o diretório em que o conteúdo foi 
extraído:
 » cd C:\mongodb-win32-x86_64-x.y.z\
 » cd bin\
Fazer isso levará você até o diretório que contém os executáveis do MongoDB. Isso é 
tudo que precisa ser feito. Nenhuma instalação será necessária.
32
CAPítulo 2
mongodB em execução
Antes de poder iniciar o serviço, é preciso criar umdiretório de dados em que o MongoDB 
irá armazenar seus arquivos. Por padrão, ele armazena os dados no diretório /data/
db em sistemas baseados em Unix (por exemplo, no Linux e no OS X) e no diretório 
C:\data\db no Windows.
O MongoDB não cria esses diretórios de dados automaticamente, portanto é preciso 
criá-los manualmente, do contrário, o MongoDB provocará uma falha na execução e irá 
gerar uma mensagem de erro. Além do mais, não se esqueça de definir as permissões 
corretamente. Devem ter permissões de leitura e de escrita, além de permissão para 
criar diretórios, para que funcione apropriadamente. 
Se quiser usar um diretório diferente de /data/db ou de C:\data\db, você poderá dizer 
ao MongoDB que olhe para o diretório desejado ao usar a flag --dbpath quando o serviço 
for executado.
Após ter criado o diretório necessário e de ter atribuído as permissões apropriadas, 
o serviço principal de banco de dados do MongoDB poderá ser iniciado por meio da 
execução da aplicação mongod. Isso pode ser feito a partir do prompt de comandos ou 
do shell no Windows e no Linux, respectivamente.
Analisando o layout da instalação
Após ter instalado e extraído o MongoDB com sucesso, você terá as aplicações mostradas 
na tabela 1 disponíveis no diretório bin (tanto no Linux quanto no Windows). 
tabela 1. as aplicações incluídas no mongodB.
Aplicação Função
-- bsondump Lê conteúdo de arquivos de rollback em formato BSON
-- mongo É o shell do banco de dados
-- mongod É o servidor principal do banco de dados
-- mongodump Utilitário de backup do banco de dados
-- mongoexport Utilitário para exportação (JSON, CSV, TSV); não é confiável para backups
-- mongofiles Manipula arquivos em objetos GridFS
-- mongoimport Utilitário de importação (JSON, CSV, TSV); não é confiável para recuperação de dados
-- mongoplog Obtém entradas de oplog de outra instância do mongod
-- mongoperf Verifica o desempenho de I/O em disco
-- mongorestore Utilitário para restauração de backup de banco de dados
-- mongos Processo de roteamento para sharding do Mongodb
33
Fazendo a Instalação do MongodB │ UnIdade II
Aplicação Função
-- mongosniff Faz sniff/trade das atividades de banco de dados MongoDB em tempo real; somente para sistemas do tipo 
Unix
-- mongostat Retorna contadores relativos à operação do banco de dados
-- mongotop Monitora/informa atividades de leitura/escrita do MongoDB
-- mongorestore Utilitário para restauração/importação
Fonte: mongodB (2017)
Todas as aplicações estão no diretório - - bin.
Os softwares instalados incluem 15 aplicações (ou 14 no Microsoft Windows) que serão 
utilizadas em conjunto com seus bancos de dados MongoDB. As duas aplicações mais 
importantes são mongo e mongod. A aplicação mongo possibilita usar o shell do banco 
de dados, esse shell permite executar praticamente tudo o que você quiser no MongoDB. 
A aplicação mongod inicia o serviço ou o daemon, como também ele é chamado. Há 
também diversas flags que podem ser definidas ao iniciar as aplicações do MongoDB. 
Por exemplo, o serviço permite especificar o path em que o banco de dados está 
localizado (--dbpath), mostra informações sobre a versão (--version) e até mesmo exibe 
algumas informações de diagnóstico do sistema (com a flag --sysinfo). A lista completa 
de opções pode ser visualizada se incluirmos a flag --help quando o serviço for iniciado. 
Por enquanto, você pode simplesmente usar os defaults e iniciar o serviço digitando 
mongod em seu shell ou no prompt de comandos. 
o shell do mongodB
Após ter criado o diretório do banco de dados e de ter iniciado a aplicação de banco de 
dados mongod com sucesso, você estará pronto para iniciar o shell e dar uma espiada 
no que o MongoDB é capaz de fazer. 
Inicie o seu shell (Unix) ou o seu prompt de comandos (Windows). Ao fazer isso, 
certifique-se de estar no local correto para que o executável do mongo possa ser 
encontrado. 
O shell pode ser iniciado ao digitar mongo no prompt de comandos e teclando Return. 
Você verá imediatamente uma janela em branco e um cursor “piscante” (veja a figura 
1). Bem-vindos ao MongoDB!
34
UNIDADE II │ FAzENDo A INstAlAção Do MoNgoDB
Figura 1. o shell do mongodB.
Fonte: pearson (2017).
Se o serviço MongoDB for iniciado com os parâmetros default e o shell for iniciado com 
as configurações default, você será conectado ao banco de dados default test, que estará 
executando em seu host local. 
Esse banco de dados é criado automaticamente no instante em que você se conectar a 
ele. Esse é um dos recursos mais eficazes do MongoDB. Se você tentar se conectar a um 
banco de dados que não exista, o MongoDB irá criá-lo automaticamente.
Antes de dar qualquer passo adicional, por exemplo, implementar um driver adicional 
que possibilite trabalhar com sua linguagem de programação favorita, você poderá 
achar útil dar uma olhada rápida em alguns dos comandos mais úteis disponíveis no 
shell do MongoDB, que podem ser vistas na tabela 2. 
tabela 2. as aplicações incluídas no mongodB.
Comando Função
show dbs Monstra os nomes dos bancos de dados disponíveis 
show collections Mostra as coleções no banco de dados corrente
show users Mostra os usuários no banco de dados corrente
use <nome do db> Define o banco de dados corrente para <nome do db>
Fonte: mongodB (2017).
Você pode obter uma lista completa dos comandos ao digitar o comando help no shell 
do MongoDB. 
35
CAPítulo 3
Suporte de drivers
A 10gen disponibiliza vários drivers oficiais e há muitos outros oferecidos pela 
comunidade. Por exemplo, os drivers para as linguagens de programação a seguir 
podem ser encontrados no site do MongoDB:
 » C
 » C++
 » C#
 » Erlang
 » Go
 » Java
 » JavaScript
 » Node.js
 » Perl
 » PHP
 » Python
 » Ruby
 » Scala
Como exemplo, iremos implementar o MongoDB em apenas uma opção de linguagem 
de programação: o PHP.
A qualquer momento é possível verificar no site <www.mongodb.com> outros drivers 
disponibilizado pela comunidade. 
O PHP é uma das linguagens de programação mais populares atualmente. Essa 
linguagem está especificamente voltada para o desenvolvimento web e pode ser 
incorporada facilmente ao HTML. Esse fato faz com que essa linguagem seja uma 
36
UNIDADE II │ FAzENDo A INstAlAção Do MoNgoDB
candidata perfeita para o design de uma aplicação web, por exemplo, um blog, um livro 
de visitas ou até mesmo um banco de dados de cartões de visita.
o mongodB sendo usado com PHP
Assim como o MongoDB, o PHP é uma ferramenta de desenvolvimento multiplataforma, 
e os passos necessários para configurar o MongoDB no PHP variam de acordo com a 
plataforma que se pretende usar. 
Já mostramos na seção anterior, como instalar o MongoDB tanto no Ubuntu quanto 
no Windows. Usaremos a mesma lógica para instalar o driver para PHP tanto em um 
quanto em outro. Comece fazendo download do driver de PHP para o seu sistema 
operacional. Faça isso iniciando o seu navegador e acessando <www.mongodb.com>. 
Como exemplo, a Figura 2 mostra a interface para o driver PHP.
Figura 2. site do mongodB para download do driver pHp.
Fonte: mongodB (2017).
Diferentes sistemas operacionais irão exigir abordagens distintas para instalar 
automaticamente a extensão do MongDDB para PHP. Do mesmo modo que você pode 
instalar o MongoDB no Ubuntu automaticamente, o mesmo poderá ser feito no caso do 
driver de PHP. E da mesma maneira que ocorreu na instalação do MongoDB no Ubuntu, 
você também pode optar por instalar o driver da linguagem PHP manualmente. Vamos 
dar uma olhada nas duas opções disponíveis a você.
37
Fazendo a Instalação do MongodB │ UnIdade II
instalando automaticamente o driver de PHP em 
plataformas baseadas em unix
Os desenvolvedores de PHP criaram uma ótima solução que permite expandir sua 
instalação de PHP com outras extensões populares: o PECL. Trata-se de um repositório 
projetado exclusivamente para o PHP, ele disponibiliza um diretório com todas as 
extensões conhecidas, que pode ser usado para fazer download,instalar e até mesmo 
desenvolver extensões PHP. Se você já conhece o sistema de gerenciamento de pacotes 
chamado aptitude (que usamos anteriormente para instalar o MongoDB), você ficará 
satisfeito com a semelhança da interface do PECL em relação ao aptitude. 
Supondo que você tenha o PECL instalado em seu sistema, abra um console e digite o 
comando a seguir para instalar a extensão do MongoDB:
$sudo pecl install mongo
Esse comando faz com que o PECL faça download e instale automaticamente a extensão 
do MongoDB para o PHP. Em outras palavras, o PECL fará o download da extensão 
para a sua versão de PHP e a colocará no diretório de extensões do PHP. Há somente 
um detalhe: o PECL não adiciona a extensão automaticamente à lista de extensões 
carregadas, será preciso executar esse passo manualmente. Para isso, abra um editor 
de texto (qualquer editor de texto de sua preferência) e altere o arquivo chamado php.
ini, que é o arquivo de configuração principal usado pelo PHP para controlar o seu 
comportamento, incluindo as extensões a serem carregadas.
A seguir, abra o arquivo php.ini, faça rolagens até a seção de extensões e acrescente a 
linha a seguir para dizer ao PHP que carregue o driver do MongoDB:
extension=mongo.so
instalando manualmente o driver de PHP em 
plataformas baseadas em unix
Se preferir compilar o driver por conta própria ou se, por algum motivo, não puder usar 
a aplicação PECL conforme descrito anteriormente (seu provedor de hosting pode não 
suportar essa opção, por exemplo), você poderá também optar por fazer o download do 
código-fonte do driver e compilá-lo manualmente.
Para fazer download do driver, acesse o site do github <http://github.com>. Esse site 
disponibiliza o pacote de códigos-fontes mais recentes para o driver de PHP. Depois de 
ter feito o download, será necessário extrair o conteúdo do pacote e executar o make 
para o driver, executando o conjunto de comandos a seguir:
38
UNIDADE II │ FAzENDo A INstAlAção Do MoNgoDB
$ tar zxvf mongodb-mongdb-php-driver-<commit_id>.tar.gz
$ cd mongodb-mongodb-php-driver-<commit_id>
$ phpize
$ ./configure
$ sudo make install
Depois que o processo estiver concluído, o seu driver para PHP do MongoDB estará 
instalado e pronto para ser usado! Após executar os comandos, você verá o local em que 
o driver foi colocado. Normalmente, a saída terá uma aparência semelhante a:
Installing ‘/ usr/lib/php/extensions/no-debug-zts-20060613/mongo.so’
É preciso confirmar se esse é o mesmo diretório em que o PHP, por padrão, armazena 
suas extensões. O comando a seguir pode ser usado para confirmar o local em que o 
PHP armazena suas extensões: 
$ php –i | grep extension_dir
Essa linha mostra o diretório em que todas as extensões do PHP devem ser colocadas. 
Se esse diretório não corresponder ao diretório em que o driver mongo.so foi colocado, 
você deverá transferir esse driver para o diretório adequado de modo que o PHP saiba 
onde encontrá-lo. 
Como antes, será preciso dizer ao PHP que a extensão recém-criada foi colocada em seu 
diretório de extensões e que ele deverá carregar essa extensão. Isso pode ser especificado 
modificando a seção de extensões do arquivo php.ini; acrescente a linha a seguir nessa 
seção: 
extension=mongo.so
Por fim, será preciso reinicializar o seu servidor de aplicação. Se o serviço Apache 
HTTPd estiver sendo usado, isso poderá ser feito por meio do comando de serviço 
a seguir:
sudo /etc/init.d/apache2 restart
Esse processo é um pouco mais longo do que usar o método automatizado do PECL. 
Entretanto, se o PECL não puder ser utilizado, ou se você for um desenvolvedor de 
driver e estiver interessado em correções de bugs, utilize o método manual.
39
Fazendo a Instalação do MongodB │ UnIdade II
instalando o driver de PHP no Windows
Anteriormente, vimos como instalar o MongoDB em seu sistema operacional Windows. 
Agora vamos ver como implementar o driver do MongoDB para PHP no Windows.
No caso do Windows, há binários pré-compilados disponíveis para cada versão do 
driver de PHP para o MongoDB. Esses binários podem ser obtidos a partir do site do 
github mencionado anteriormente (http://github.com). O maior desafio, nesse caso, 
é escolher o pacote correto a ser instalado para a sua versão de PHP (uma enorme 
variedade de pacotes está disponível). Se você não estiver certo sobre a versão do pacote 
de que precisará, o comando <? phpinfo(); ?> poderá ser usado em uma página PHP 
para saber exatamente qual delas é adequada ao seu ambiente especifico. 
Após ter feito download do pacote correto e de ter extraído o seu conteúdo, tudo que é 
preciso fazer é copiar o arquivo do driver (chamado php_mongo.dll) para o seu diretório 
de extensões do PHP, isso permite que o PHP o carregue. 
Conforme a versão de seu PHP, o diretório de extensões pode ser chamado Ext ou 
Extensions. Se não tiver certeza de qual deve ser o diretório, você poderá examinar a 
documentação do PHP que acompanha a versão instalada em seu sistema.
Após ter colocado a DLL do driver no diretório de extensões do PHP, será necessário 
dizer ao PHP para carregar o driver. Faça isso alterando o arquivo php.ini e adicionando 
a seguinte linhana seção de extensões:
extension=php_mongo.dll
Após, reinicie o servidor de aplicação do seu sistema e estará pronto para usar o driver 
do MongoDB no PHP.
40
unidAdE iiimodElAgEm do 
mongodB
CAPítulo 1
Como modelar?
Nessa última unidade, desviaremos nossa atenção do sistema operacional e passaremos 
a analisar o design geral de um banco de dados MongoDB. Especificamente, você 
aprenderá o que são coleções, qual é a aparência de um documento, como os 
índices funcionam e o que eles fazem. 
Evolução dos modelos de dados
Não se pode falar dos modelos de dados atuais sem antes fazer uma referência aos 
antigos modelos de dados que de certa forma foram úteis e impulsionaram o surgimento 
de outros modelos. Desde os primórdios da informática, o homem tem procurado 
encontrar a melhor forma de armazenar e manipular informações do seu mundo real, 
em sistemas informatizados. Antes dos modernos sistemas de gestão de bases de dados, 
outras formas de armazenamento e modelos de dados foram utilizadas, cujas mais 
populares serão apresentadas a seguir.
Sistema de gestão de ficheiros (Sgf)
A primeira forma encontrada para lidar com o armazenamento de dados baseou-se 
nos Sistemas de Gestão de Ficheiros (SGF), que representam uma forma de organizar 
e armazenar dados em meios de armazenamento em massa. Com os SGF foi possível 
automatizar algumas tarefas, que até então eram realizadas manualmente, tornando a 
execução dessas tarefas mais rápida. Para cada nova aplicação era necessário definir 
novos ficheiros de dados e desenvolver os programas necessários para os processamentos 
específicos. 
Nos SGF cada sistema era considerado como um sistema isolado, sem relação com 
outros sistemas já existentes.
Mas os sistemas de gestão ficheiros apresentavam, no entanto, algumas limitações, 
como por exemplo, a dificuldade em fazer o controle de acesso, quando o sistema ou 
41
ModelageM do MongodB │ UnIdade III
aplicação era utilizado por vários utilizadores ou por vários processos ao mesmo tempo. 
Para além dessas limitações, existiam outros inconvenientes nos SGF, nomeadamente:
 » Redundância de informação – originada pela forma desarmonizada de 
criar os ficheiros e da forma independente de efetuar atualizações dos 
dados, que dava origem a duplicação de dados.
 » Inconsistência dos dados – muitas vezes uma consequência direta da 
redundância.
 » Dificuldade em extrair a informação – devido à estrutura dos ficheiros 
que dificultava o acesso aos campos nos quais estava a informação.
 » Informação dispersa – estando os dados em diferentes ficheiros, uma 
mesma informação poderia ser encontrada em formatos diferentes, em 
cada um dos ficheiros.
 » Integridade dos dados – tarefa difícil de conseguir e que só poderia ser 
assegurada, mediante a criação de regras em cada aplicaçãoque fizesse 
uso dos ficheiros.
modelo de dados hierárquico
Um banco de dados hierárquico consiste em uma coleção de registros que são 
conectados uns aos outros por meio de ligações. Um registro é uma coleção de campos, 
cada qual contendo apenas um valor de dados. Uma ligação é uma associação entre 
exatamente dois registros. O modelo hierárquico é, portanto, similar ao modelo de rede, 
no sentido de que dados e relacionamentos entre dados são também representados por 
registros e ligações, respectivamente. O modelo hierárquico difere do modelo de rede 
na organização de registros como coleção de árvores ao invés de grafos arbitrários, 
conforme pode ser visto na Figura 3.
Figura 3. modelo de dados Hierárquico. 
Fonte: Korth (1995).
42
UNIDADE III │ MoDElAgEM Do MoNgoDB
Um diagrama com estrutura de árvore é um esquema para um banco de dados 
hierárquico. Tal diagrama consiste em dois componentes básicos: retângulos, 
que correspondem a tipos de registro, e linhas, que correspondem às ligações. 
O diagrama com estrutura de árvore serve para os mesmos propósitos que um diagrama 
entidade-relacionamento; a saber, ele especifica a estrutura lógica geral do banco 
de dados. Um diagrama com estrutura de árvore é similar ao diagrama de estrutura 
de dados no modelo de rede. A principal diferença é que, no primeiro, tipos de 
registro são organizados na forma de uma árvore enraizada. Para todo diagrama 
entidade-relacionamento, existe um diagrama com estrutura de árvore correspondente. 
O esquema de banco de dados é, portanto, representado como uma coleção de 
diagramas com estrutura de árvore. Para cada diagrama, existe uma única instância 
de uma arvore do banco de dados. A raiz dessa árvore é um nó auxiliar. Os filhos 
desse nó são instâncias, de fato, do tipo de registro apropriado. Cada instância pode, 
por sua vez ter diversas instâncias de vários tipos de registro, como especificadas no 
diagrama com estrutura de árvore correspondente.
A linguagem de manipulação de dados consiste em uma série de comandos que 
são embutidos em uma linguagem hospedeira. Esses comandos fazem o acesso e 
manipulam itens do banco de dados assim como variáveis declaradas localmente. Para 
cada programa de aplicação o sistema mantém uma área de trabalho de programa que 
contém gabaritos de registro, ponteiros correntes e indicadores de estado.
Os itens de dados são buscados por meio do comando get, que localiza um registro no 
banco de dados e posiciona o ponteiro corrente para apontar para ele, e então copia 
aquele registro do banco de dados para o gabarito de área de trabalho do programa 
apropriado. Existe uma série de diferentes formas do comando get. A principal distinção 
entre elas é se um registro deve ser localizado dentro de toda a árvore de um banco de 
dados ou dentro de uma sub-árvore.
Vários mecanismos estão disponíveis para atualizar informações no banco de dados. 
Eles incluem a criação e a remoção de registros (via operações insert e delete) e a 
modificação (via operação replace) do conteúdo dos registros existentes. No caso de 
relacionamentos muitos-para-muitos, a duplicação de registros é necessária para 
preservar a estrutura de árvore do banco de dados. A duplicação de registros tem dois 
inconvenientes principais: atualizações podem levar a inconsistência de dados e o 
desperdício de espaço é inevitável. A solução é o registro virtual, tal registro não contém 
valores de dados, ele contém um ponteiro lógico para um registro físico. Quando um 
registro é duplicado em diversas árvores de banco de dados, uma única cópia daquele 
registro é mantida em uma das árvores e todas as outras ocorrências são substituídas 
por um registro virtual contendo um ponteiro para aquele registro físico. A linguagem 
43
ModelageM do MongodB │ UnIdade III
de manipulação de dados para essa nova configuração leva ao mesmo caso em que a 
duplicação de registro é permitida. Assim, um usuário não precisa preocupar-se com 
essas mudanças.
A implementação de bancos de dados hierárquicos não usa ponteiros pai-filho, uma 
vez que eles requerem o uso de registros de tamanho variável. Em vez disso, são usadas 
cadeias em pré-ordem. Essa técnica permite que cada registro contenha exatamente dois 
ponteiros. Opcionalmente, um terceiro ponteiro filho – para – pai pode ser adicionado 
(KORTH, 1995).
modelo de dados em rede 
O modelo em redes surgiu como uma extensão ao modelo hierárquico, eliminando o 
conceito de hierarquia e permitindo que um mesmo registro estivesse envolvido em 
várias associações. 
No modelo em rede, os registros são organizados em grafos onde aparece um único tipo 
de associação (set) que define uma relação 1:N entre 2 tipos de registros: proprietário 
e membro. Desta maneira, dados dois relacionamentos 1:N entre os registros A e D e 
entre os registros C e D é possível construir um relacionamento M:N entre A e D. 
O gerenciador Data Base Task Group (DBTG) criado pela CODASYL (Committee on 
Data Systems and Languages) nos anos 70 já estabelecia normas que prevaleciam nos 
modelos de banco de dados, com linguagem própria para definição e manipulação de 
dados. Os dados tinham uma forma limitada de independência física. A única garantia 
era que o sistema deveria recuperar os dados para as aplicações como se eles estivessem 
armazenados na maneira indicada nos esquemas. Os geradores de relatórios da CODASYL 
também definiram sintaxes para dois aspectos chaves dos sistemas gerenciadores de 
dados: concorrência e segurança. O mecanismo de segurança fornecia uma facilidade 
na qual parte do banco de dados (ou área) pudesse ser bloqueada para prevenir acessos 
simultâneos, quando necessário. A sintaxe da segurança permitia que uma senha fosse 
associada a cada objeto descrito no esquema. Ao contrário do Modelo Hierárquico, em 
que qualquer acesso aos dados passa pela raiz, o modelo em rede possibilita acesso a 
qualquer nó da rede sem passar pela raiz. O diagrama para representar os conceitos do 
modelo em redes consiste em dois componentes básicos: Caixas, que correspondem aos 
registros e Linhas, que correspondem às associações.
fazendo o design do banco de dados
O banco de dados MongoDB não é relacional nem tem esquemas. Significa que um 
banco de dados MongoDB não está associado a nenhuma coluna ou tipo de dado 
44
UNIDADE III │ MoDElAgEM Do MoNgoDB
predefinido como ocorre com bancos de dados relacionais (por exemplo, o MySqL). 
A principal vantagem dessa implementação é a extrema flexibilidade para trabalhar com 
os dados, pois não há nenhuma estrutura predefinida necessária em seus documentos.
Falando de maneira simples você será perfeitamente capaz de ler uma coleção que 
contenha centenas ou até mesmo milhares de documentos, cada qual com uma estrutura 
diferente sem transgredir nenhuma regra dos bancos de dados MongoDB. 
Uma das vantagens desse design flexível e sem esquemas é que você não terá restrições 
ao programar em uma linguagem com tipos dinâmicos como Python ou PHP. Com 
efeito, se sua linguagem de programação for extremamente flexível e dinâmica não 
poderia ser usada em todo o seu potencial por causa das restrições inatas de seu banco 
de dados, isso constituiria uma severa limitação. 
Vamos dar outra olhada na aparência do design de dados em um documento do 
MongoDB, prestando atenção em particular à maneira como os dados são flexíveis nesse 
banco de dados quando comparados a um banco de dados relacional. No MongoDB, um 
documento é um item que contém os dados propriamente ditos e é comparável a uma 
linha no SQL. No exemplo a seguir, você verá como dois tipos totalmente diferentes de 
documento podem coexistir em uma única coleção chamada Media (observe que uma 
coleção, de modo geral, é o equivalente a uma tabela do mundo SQL):
{
“Type”: “CD”,
“Artist”: “Nirvana”,
“Title’: “Nevernind”,
“Genre”: “Grunge”,
“Releasedate”: “1991.09.24”,
“Tracklist”: [
{
“Track” : “1”,
“Title” : “Smells Like Teen Spirit”,
“Length” : “5:02”
},
45
ModelageMdo MongodB │ UnIdade III
{
“Track” : “1”,
“Title” : “In Bloom”,
“Le,gth” : “4:15”
}
]
}
{
“type”: “Book”,
“Title”: “Definitive Guide to MongoDB : A complete guide to dealing with Big 
Data
using MongoDB 2nd, The”,
“ISBN”: “987-1-4302-5821-6”,
“Publisher”: “Apress”,
“Author”: [
“Hows, David”
“Plugge, Eelco”,
“Membrey, Peter”,
“Hawkins, Tim
]
}
Como você pode ter percebido ao observar esse par de documentos, a maioria dos 
campos não tem uma relação muito próxima. Sim, ambos têm campos chamados 
Title e Type, entretanto, exceto por essa semelhança, os documentos são totalmente 
diferentes. Apesar disso, esses dois documentos estão contidos em uma única coleção 
chamada Media. 
46
UNIDADE III │ MoDElAgEM Do MoNgoDB
O MongoDB é chamado de banco de dados sem esquemas (schemaless), mas isso não 
significa que sua estrutura de dados seja completamente desprovida de esquemas. Por 
exemplo, você deve definir coleções e índices no MongoDB. Contudo não é necessário 
predefinir uma estrutura para nenhum dos documentos que serão adicionados, como 
ocorre quando trabalhamos com o MySQL, por exemplo. Falando de maneira simples, 
o MongoDB é um banco de dados extraordinariamente dinâmico, o exemplo anterior 
jamais funcionaria em um banco de dados relacional, a menos que você também 
adicionasse cada possível campo à sua tabela. Fazer isso seria um desperdício de 
espaço e pioraria o desempenho, sem mencionar que haveria um elevado nível de 
desorganização.
Explorando as coleções
Você pode pensar em uma coleção como um contêiner que armazene seus documentos 
(ou seja, dados), conforme Figura 4.
Figura 4. o modelo de um banco de dados mongodB.
Fonte: o autor (2017).
Agora compare o modelo do banco de dados do MongoDB com um modelo típico de 
um banco de dados relacional (veja a figura 5). Como podemos ver, a estrutura geral é a 
mesma nos dois tipos de banco de dados, apesar disso, eles não são utilizados, nem de 
longe, de maneira semelhante.
47
ModelageM do MongodB │ UnIdade III
Figura 5. o modelo típico de um banco de dados relacional.
Fonte: o autor (2017).
Há vários tipos de coleções no MongoDB. O tipo de coleção default é expansível quanto 
ao tamanho: quanto mais dados forem adicionados, maior será a coleção. Também é 
possível definir coleções que sejam do tipo “capped” (coleção limitada). 
Toda coleção no MongoDB tem um nome único. Esse nome deve começar com uma 
letra ou, opcionalmente, com um underscore ( _ ), quando criado por meio da função 
createcollection. O nome pode conter números e letras, mas o símbolo $ é reservado 
para uso do mongodb. De modo semelhante, usar uma string vazia (“ “) não é permitido, o 
caractere nulo não pode ser usado no nome, que tampouco poderá começar com a string 
“system.”. Em geral, é recomendável manter o nome da coleção simples e compacto 
(cerca de nove caracteres). No entanto, o número máximo de caracteres permitido para 
o nome de uma coleção é 118, menos o número de caracteres do nome do banco de 
dados e o caractere ponto adicional usado como separador. Obviamente, não há muitos 
motivos práticos para criar um nome tão longo assim. 
A combinação mencionada anteriormente, composta pelo nome do banco de dados, 
“ponto” e o nome da coleção, é chamada de namespace. Um único banco de dados tem 
um limite default de 24 mil namespaces. Cada coleção tem pelo menos dois namespaces: 
um para a coleção propriamente dita e mais um para o indice_id default criado para 
a coleção. Porém, se você acrescentar mais índices por coleção, outro namespace será 
usado. Teoricamente, isso significa que cada banco de dados pode ter até 12 mil coleções 
por padrão, supondo que cada coleção tenha somente um índice. Entretanto esse limite 
na quantidade de namespaces pode ser aumentado se fornecermos o parâmetro nssize 
quando a aplicação do serviço MongoDB (mongod) for executada.
48
UNIDADE III │ MoDElAgEM Do MoNgoDB
usando documentos
Um documento é constituído de pares de chave-valor. Por exemplo, o par “type”: 
“Book” é constituído de uma chave chamada type e de seu valor Book. As chaves são 
escritas na forma de strings, porém seus valores podem variar enormemente. Os valores 
podem ter qualquer tipo de dado entre um conjunto variado, por exemplo, podem ser 
arrays ou até mesmo dados binários. Lembre-se de que o MongoDB armazena seus 
dados em formato BSON.
Abaixo seguem todos os tipos de dados possíveis que podem ser adicionados a um 
documento e com que finalidades eles são utilizados:
String Esse tipo de dado comumente usado contém uma string texto (ou qualquer outro tipo de caractere). É 
usado principalmente para armazenar valores textuais (por exemplo, {“Country” : “Japan”}).
Integer (inteiro, 32b e 
64b)
É usado para armazenar um valor numérico (por exemplo, { “Rank” : 1 } ). Observe que não há aspas antes 
nem depois do inteiro.
Boolean (booleano) Esse tipo de dado pode ser definido como TRUE ou FALSE.
Double É usado para armazenar valores de ponto flutuante.
Chaves Min/Max É usado para comparar um valor em relação aos elementos BSON de valor mínimo e máximo, 
respectivamente.
Arrays É usado para armazenar arrays. Por exemplo, [“Membrey, Peter”, “Plugge”, Eelco”, “Hows, David”].
Timestamp É usado para armazenar um timestamp. Pode ser prático para registrar o momento em que um documento 
foi modificado ou adicionado. 
Object (objeto) É usado para documentos internos (embedded documents)
Null (nulo) É usado para um valor igual a Null
Symbol (símbolo) É usado da mesma maneira que uma string, entretanto, em geral é reservado para linguagens que utilizam 
um tipo específico de símbolo.
Date (data) É usado para armazenar a data ou a hora correntes em formato de tempo Unix (tempo POSIX).
Object ID (ID de objeto) É usado para armazenar o ID do documento.
Binary data (dados 
binários)
É usado par armazenar dados binários.
Regular expression 
(expressão regular)
É usado para expressões regulares. Todas as opções são representadas por caracteres específicos em 
ordem alfabética.
JavaScript Code (código 
JavaScript)
É usado para código JavaScript.
Fonte: mongodB (2017).
Os cinco últimos tipos de dados (data, ID de objeto, dados binários, regex e código 
JavaScript) não são tipos JSON especificamente, são tipos especiais de dados que o 
BSON permite usar. 
Teoricamente, tudo isso provavelmente soa como se fosse algo muito simples. Porém, 
você poderá estar se perguntando como realmente fará o design do documento, incluindo 
que informações serão inseridas nele. Pelo fato de um documento poder conter qualquer 
tipo de dado, você pode achar que não haverá necessidade de referenciar informações 
a partir de outro documento.
49
CAPítulo 2
momento integração
Após conhecer alguns recursos do banco de dados NoSQL MongoDB, vamos apresentar 
algumas integrações de tecnologias.
usar o mongoChef com uma conta do Azure 
Cosmos dB: APi para mongodB
Vi recentemente algumas integrações e uma me chamou atenção: conectar a uma conta 
do Azure Cosmos DB usando API para MongoDB! Para isso é necessário:
1. Baixar e instalar o MongoChef2;
2. Ter as informações de cadeia de conexão de sua conta do Azure Cosmos 
DB: API para MongoDB.
Caso você tenha visto algo sobre Azure Cosmos DB, ótimo! Pule para seção 2.3. Caso 
não conheça, abaixo trago os conceitos do Azure.
Azure Cosmos dB
O BD Cosmos do Azure é o multimodelo de banco de dados distribuído globalmente 
da Microsoft. Com o clique de um botão, o BD Cosmos do Azure permite que você 
dimensione a taxa de transferência e o armazenamento de maneira elástica e 
independente em qualquer número de regiões geográficas do Azure. Ele oferece 
garantias de taxa de transferência, disponibilidade, latência e consistência com SLAs 
(contratos de nível de serviço) abrangentes, algo que nenhum outro serviço de banco de 
dados pode oferecer. Você pode experimentar o Azure Cosmos DB sem uma assinatura 
do Azure, gratuitamente e sem compromisso conforme a Figura 6 .
2 <https://studio3t.com/>.50
UNIDADE III │ MoDElAgEM Do MoNgoDB
Figura 6. azure cosmos dB.
Fonte: microsoft (2017).
Como um serviço de banco de dados distribuído globalmente, o Azure Cosmos DB 
fornece as seguintes funcionalidades para ajudá-lo a criar aplicativos altamente 
responsivos e escalonáveis:
 » Distribuição global turnkey;
 » Vários modelos de dados e APIs populares para acessar e consultar dados;
 » Dimensionar elasticamente a taxa de transferência e o armazenamento 
sob demanda, em todo o mundo;
 » Criar aplicativos altamente responsivos e críticos;
 » Garantir disponibilidade “sempre ativa”;
 » Escrever aplicativos distribuídos globalmente, da maneira correta;
 » Garantia do dinheiro de volta;
 » Sem gerenciamento de esquema/índice de banco de dados;
 » Baixo custo de propriedade.
Qualquer sistema web, aplicativos para celular, jogos e aplicativos de IoT que precisam 
lidar com grandes quantidades de leituras e gravações em uma escala global com baixo 
tempo de resposta para uma variedade de dados se beneficiará da disponibilidade, 
alta taxa de transferência, baixa latência e consistência ajustável garantida do Azure 
Cosmos DB.
51
ModelageM do MongodB │ UnIdade III
Criar uma conexão com mongoChef
Para adicionar sua conta do Azure Cosmos DB (API para MongoDB) ao gerenciador de 
conexões do MongoChef, realize as etapas a seguir.
1. Recupere as informações de conexão do Azure Cosmos DB usando as 
instruções descritas aqui.
Figura 7. conexão com o mongochef.
Fonte: microsoft (2017).
2. Clique em Conectar para abrir o Gerenciador de Conexões e clique em 
Nova Conexão
Figura 8. nova conexão com o mongochef.
Fonte: microsoft (2017).
52
UNIDADE III │ MoDElAgEM Do MoNgoDB
3. Na janela Nova Conexão, na guia Servidor, insira o HOST da conta do 
Azure Cosmos DB e a porta.
Figura 9. configurando servidor.
Fonte: microsoft (2017).
4. Na janela Nova Conexão, na guia Autenticação, escolha o Padrão do 
Modo de Autenticação (MONGODB-CR ou SCARM-SHA-1) e insira 
USERNAME e PASSWORD. Aceite o banco de dados de autenticação 
padrão (admin) ou forneça seu próprio valor.
Figura 10. configurando servidor.
Fonte: microsoft (2017).
53
ModelageM do MongodB │ UnIdade III
5. Na janela Nova Conexão, na guia SSL, marque a caixa de seleção Usar 
protocolo SSL para se conectar e o botão de opção Aceitar certificados 
SSL de servidor autoassinados.
Figura 11. Habilitando ssl.
Fonte: microsoft (2017).
6. Clique no botão Testar Conectividade para validar as informações de 
conexão, clique em OK para retornar à janela Nova Conexão e clique em 
Salvar.
Figura 12. teste de conexão.
Fonte: microsoft (2017).
54
UNIDADE III │ MoDElAgEM Do MoNgoDB
usar o mongoChef para criar um banco de dados, 
uma coleção e documentos
Para criar um banco de dados, uma coleção e documentos usando o MongoChef, execute 
as etapas a seguir.
1. No Gerenciador de Conexões, realce a conexão e clique em Conectar.
Figura 13. gerenciador de conexões.
Fonte: microsoft (2017).
2. Clique com o botão direito do mouse e escolha Adicionar Banco de 
Dados. Forneça um nome de banco de dados e clique em OK.
Figura 14. adicionando uma nova base de dados.
Fonte: microsoft (2017).
55
ModelageM do MongodB │ UnIdade III
3. Clique com o botão direito do mouse no banco de dados e escolha 
Adicionar Coleção. Forneça um nome de coleção e clique em Criar.
Figura 15. adicionando coleções.
Fonte: microsoft (2017).
4. Clique no item de menu Coleção e clique em Adicionar Documento.
Figura 16. adicionando documentos.
Fonte: microsoft (2017).
56
UNIDADE III │ MoDElAgEM Do MoNgoDB
5. Na caixa de diálogo Adicionar Documento, cole o conteúdo a seguir e 
clique em Adicionar Documento.
{
 “_id”: “AndersenFamily”,
 “lastName”: “Andersen”,
 “parents”: [
{ “firstName”: “Thomas” },
{ “firstName”: “Mary Kay”}
 ],
 “children”: [
{
“firstName”: “Henriette Thaulow”, “gender”: “female”, “grade”: 5,
 “pets”: [{ “givenName”: “Fluffy” }]
 }
 ],
 “address”: { “state”: “WA”, “county”: “King”, “city”: “seattle” },
 “isRegistered”: true
 }
Adicione outro documento, dessa vez com o conteúdo a seguir.
{
 “_id”: “WakefieldFamily”,
 “parents”: [
57
ModelageM do MongodB │ UnIdade III
{ “familyName”: “Wakefield”, “givenName”: “Robin” },
{ “familyName”: “Miller”, “givenName”: “Ben” }
 ],
 “children”: [
{
“familyName”: “Merriam”,
“givenName”: “Jesse”,
“gender”: “female”, “grade”: 1,
“pets”: [
{ “givenName”: “Goofy” },
{ “givenName”: “Shadow” }
]
},
{
“familyName”: “Miller”,
“givenName”: “Lisa”,
“gender”: “female”,
“grade”: 8 }
 ],
 “address”: { “state”: “NY”, “county”: “Manhattan”, “city”: “NY” },
 “isRegistered”: false
 }
58
UNIDADE III │ MoDElAgEM Do MoNgoDB
6. Execute uma consulta de exemplo. Por exemplo, procure famílias com o 
sobrenome ‘Andersen’ e retorne os campos de estado e país.
Figura 17. executando uma consulta.
Fonte: microsoft (2017).
Conectar um aplicativo do mongodB ao Azure 
Cosmos dB
Para conectar seu aplicativo do MongoDB a uma conta do Azure Cosmos DB usando 
uma cadeia de conexão do MongoDB você pode usar um banco de dados do Azure 
Cosmos DB como o armazenamento de dados para seu aplicativo MongoDB.
E como recuperar informações da cadeia de conexão? Seguiremos dois passos:
1. O método de início rápido: para uso com drivers do .NET, Node.js, Shell 
do MongoDB, Java e Python
2. O método de cadeia de conexão personalizada: para uso com outros 
drivers
Porém para tal, são necessários alguns prerrequisitos:
 » Uma conta do Azure. 
 » Uma conta do Azure Cosmos DB.
59
ModelageM do MongodB │ UnIdade III
Vejamos como obter a cadeia de conexão do MongoDB usando o início rápido:
1. Em um navegador da Internet, entre no Portal do Azure.
2. Na folha (aba) Azure Cosmos DB, selecione a API da conta MongoDB.
3. No painel esquerdo da folha (aba) da conta, clique em Início rápido.
4. Escolha sua plataforma (.NET, Node.js, MongoDB Shell, Java, Python).
5. Copie e cole o trecho de código no seu aplicativo MongoDB.
Figura 18. escolhendo api mongodB.
Fonte: microsoft (2017).
Vejamos como obter a cadeia de conexão do MongoDB para personalização:
1. Em um navegador da Internet, entre no Portal do Azure.
2. Na folha (aba) Azure Cosmos DB, selecione a API da conta MongoDB.
60
UNIDADE III │ MoDElAgEM Do MoNgoDB
3. No painel esquerdo da folha (aba) de conta, clique em Cadeia de Conexão 
(Connection String).
4. A folha (aba) de Cadeia de Conexão é aberta. Ela tem todas as informações 
necessárias para se conectar a conta usando um driver para MongoDB, 
incluindo uma cadeia de conexão pré-construída.
Figura 19. configurando conexões.
Fonte: microsoft (2017).
61
CAPítulo 3
E o que esperar do mongodB? fazendo 
um overview!
Conforme foi visto, o MongoDB é um banco de dados orientado a documentos que 
utiliza o conceito de dados e documentos autocontidos e autodescritivos, e isso implica 
que o documento em si já define como ele deve ser apresentado e qual é o significado 
dos dados armazenados na sua estrutura.
Devemos lembrar que os bancos de dados orientados nos documentos têm como 
característica conter todas as informações importantes em um único documento, ser 
livre de esquemas, possuir identificadores únicos universais (UUID), possibilitar a 
consulta de documentos por meio de métodos avançados de agrupamento e filtragem 
(MapReduce) e também permitir redundância e inconsistência.
Para Kyle (2011), esses bancos de dados também são chamados de Bancos NoSQL (Not 
Only SQL). Esse termo NoSQL é devido à ausência do SQL, mas esse tipo de banco de 
dados não se resume apenas a isso, portanto o termo não é o mais correto para esse 
novo tipo de banco de dados. No entanto, ele é aceito porque o termo já se popularizou 
na comunidade. Alguns chegaram a defender o termo NoREL (Not Relational), mas 
diferente do anterior este não foi muito aceito. De forma resumida, esse tipo de banco 
de dados não traz consigo as ideias do modelo relacional e nem a linguagem SQL.Uma diferença fundamental entre os dois modelos surge quando precisamos criar 
relacionamentos nos bancos de dados relacionais, diferente dos bancos orientados a 
documentos que não fornecem encadeamento entre documentos, o que mantém seu 
design sem esquemas. Dessa forma, ao invés de armazenar dados relacionados em 
uma área de armazenamento separado, os bancos de dados de documentos integram 
esses dados ao próprio documento. Contudo, ainda assim é possível armazenar dados 
relacionados de forma separada, isso pode ser feito usando uma coleção separada, 
porém, é preciso tomar cuidado com isso visto que os ganhos de desempenhos podem 
ser perdidos.
Além do MongoDB, existem diversos banco de dados NoSQL hoje, são eles: DynamoDB, 
MarkLogic, CouchDB, entre outros. Nesta seção abordaremos alguns.
Suas características
O MongoDB tem como característica ser código-fonte aberto licenciado pela GNU AGPL 
(Affero General Public License), possuindo alta performance, não possuir esquemas, 
62
UNIDADE III │ MoDElAgEM Do MoNgoDB
ser escrito em C++, multiplataforma e ser formado por um conjunto de aplicativos 
JSON. Apesar do projeto MongoDB ter iniciado em 2007, o banco de dados somente 
foi concluído em 2009, lançando assim a primeira versão do MongoDB. Diversas 
linguagens e plataformas já possuem drivers para o MongoDB, entre elas destacam-se: 
C, C#, C++, Haskell, Java, JavaScript, Perl, PHP, Python, Ruby e Scala. Além disso, o 
MongoDB possui binários para diversas plataformas como Windows, Mac OS X, Linux 
e Solaris.
Entre as empresas que já utilizam o MongoDB destacam-se: Globo.com, SourceForge, 
FourSquare, MailBox (serviço de e-mail do Dropbox), LinkedIn, SAP, MTV, Pearson 
Education, e muitos outros. Uma lista com todos os serviços em ambiente de 
produção que estão utilizando o MongoDB pode ser encontrado em: <http://www.
mongodb.com/>.
Vantagens
Utilizando MongoDB temos uma melhor performance, visto que uma única consulta 
retorna tudo o que precisamos saber sobre o documento.
Os bancos de dados NoSQL apresentam vantagens sobre os outros quando precisamos 
de escalabilidade, flexibilidade, manipulação de quantidade massiva de dados, bom 
desempenho e facilidade para consultas.
O MongoDB possui consultas bastante simples de serem realizadas, observando 
quenão existem transações e joins. As consultas são mais fáceis de escrever e mais 
fáceis de ajustar.
Como a linguagem de consulta SQL é fácil de ser convertida para MongoDB temos 
uma maior facilidade para migração de organizações que atualmente usam bancos de 
dados relacionais.
Por fim, o MongoDB também possui a funcionalidade chamada GridFS que é 
responsável por armazenar arquivos de grandes dimensões. Isso significa que vídeos, 
arquivos etc., podem ser armazenados diretamente no banco de dados, diferente do 
modelo relacional que tínhamos que armazenar tudo no Filesystem e disponibilizar 
apenas uma referência para esses arquivos no banco de dados. O tempo de resposta 
desses arquivos armazenados no MongoDB é comparado ao tempo de resposta dos 
arquivos em Filesystems.
63
ModelageM do MongodB │ UnIdade III
desvantagens
Uma desvantagem é quando queremos alterar todos os registros relacionados a uma 
unidade semântica, nesse caso é preciso tratar um a um. (KYLE, 2011).
Uma pergunta a ser respondida ainda é a dúvida que todos os usuários possuem em 
relação ao suporte do MongoDB que todas as grandes empresas e projetos de alto valor 
necessitam. Até que ponto o MongoDB oferece esse suporte necessário? Outro ponto 
é em relação à disponibilidade do serviço. Essas e outras perguntas serão respondidas 
ao longo do tempo, o fato é que muitas empresas de grande porte tem utilizado em 
projetos de complexidade média, uma escolha natural devido ao pequeno tempo que 
essa nova tecnologia está no mercado e os resultados têm sido muito satisfatórios.
outras plataformas noSql
marklogic
MarkLogic é uma empresa baseada no Vale do Silício, fundada em 2001, que cria o que 
ela define como “o único banco de dados NoSQL empresarial” no mercado. Começando 
com as suas raízes na base de dados XML, a empresa alavancou mais de uma década da 
experiência no desenvolvimento de soluções para dados não estruturados, levando-a a 
ganhar o rótulo de “empresa NoSQL”.
MarkLogic define sua solução como um servidor de banco de dados focado em documento, 
transacional, focado em pesquisa, estruturado, sem esquemas, programático, de alto 
desempenho, e clusterizado. Ela é amplamente implantada no mercado editorial, no 
governo, nas finanças e em outros setores, com centenas de sistemas de larga escala na 
produção. Foi usado como o principal banco de dados para os Jogos Olímpicos de Verão 
de 2012 em Londres, bem como pela Administração Federal de Aviação dos Estados 
Unidos, o que sinaliza a merecida reputação do MarkLogic como uma plataforma 
altamente escalável, robusta e segura para as soluções de Big Data.
CouchdB
Uma recente rodada de financiamento de US$ 60 milhões fez do Couchbase um dos 
bancos de dados NoSQL emergentes e recém-populares no mercado hoje, rivalizando 
com MongoDB. Uma das principais áreas em que o Couchbase inovou foi no 
fornecimento de escalabilidade simplificada e desempenho para aplicativos interativos 
na interseção do que ele chama de “três megatendências inter-relacionadas – Big Data, 
Big Users e Cloud Computing”. O Cloudbase também pressionou o gerenciamento de 
64
UNIDADE III │ MoDElAgEM Do MoNgoDB
dados de ofertas móveis, permitindo aos usuários sincronizar facilmente dados entre 
dispositivos móveis e nuvem.
A tecnologia de código aberto do Couchbase está disponível em duas versões: uma 
edição comunitária que vem sem correções de bugs recentes, e a estável Enterprise 
Edition, para uso comercial. Os builds do Couchbase estão disponíveis para Ubuntu, 
Red Hat, plataformas Windows e Mac OS X.
dynamodB
O DynamoDB da Amazon é um serviço de banco de dados NoSQL totalmente proprietário 
que utiliza a imensa infraestrutura de computação em nuvem da Amazon. Ele é o ápice 
de 15 anos de experiência na construção de bancos de dados não relacionais para as 
próprias necessidades internas da Amazon e representa a versão baseada em nuvem 
dessa tecnologia desenvolvida para clientes externos.
Com o DynamoDB, tudo que você tem a fazer é criar a tabela de banco de dados, e o serviço 
faz o resto. À medida que você escalona, não há necessidade para provisionamento 
de hardware ou de software, configurações e setups, aplicação de patches de software, 
operação de um cluster de banco de dados distribuído ou a necessidade de dividir os 
dados pelas várias instâncias. DynamoDB é o único que funciona com base no princípio 
da “taxa de transferência” em vez de armazenamento. Com base nesse modelo, o serviço 
Amazon DynamoDB irá garantir que aloca os recursos da máquina para atender às suas 
necessidades de taxa de transferência, juntamente com a garantia de um desempenho 
consistente, de baixa latência.
O modelo do Amazon de “pagar apenas pelo que usa”, sem taxa mínima e escalabilidade 
de baixo custo, torna-o uma maneira barata e acessível para as empresas aproveitarem 
os últimos avanços em desempenho NoSQL.
65
unidAdE iVAtiVidAdE PrátiCA
CAPítulo 1
Vamos que vamos!
Antes de iniciarmos a prática, é interessante buscarmos uns conceitos complementares 
ao que já foi visto nesse material, vamos lá!
mongodB
O MongoDB consiste em dois serviços: mongod e mongos. O mongos é usado para 
autosharding. Sharding é uma distribuição física de dados em nós distintos, utilizando 
quando é necessário o balanceamento de carga.
O mongod é o servidor do banco de dados. É altamente recomendável que mongod rode 
em um sistema operacional de 64 bits, já que o tamanho máximo para um banco de 
dados na arquitetura de 32 bits é 2 gigabytes.
Além do servidor, o MongoDB possui um serviço de cliente de shell padrão, o mongos, 
que é usado para uma conexão ao servidor pela porta 27017, mas além deste cliente, 
estãodisponíveis em vários drivers oficiais para linguagens como PHP, JAVA, C, C ++, 
entre outros. 
O servidor do MongoDB pode armazenar um ou mais bancos de dados diferentes, em 
que cada base de dados é composta por uma ou mais coleções e cada coleção é possível 
ter um ou mais documentos. Esses documentos são estruturados como documentos 
JSON e armazenados no formato BSON (JSON binário).
JSON (JavaScript Object Notation) é uma estrutura de dados criada em javascript, 
que consiste no padrão atributo/valor, semelhante aos arrays. O JSON pode ser uma 
alternativa ao XML, no qual às vezes se destaca sem qualquer dúvida em relação à 
velocidade de leitura dos dados armazenados nele.
66
UNIDADE IV │ AtIVIDADE PrátIcA
Exemplo de estrutura JSON:
{“Nome”: “joão”, “idade”: “20”}, {“nome”: “maria”, “idade”: “22”}.
No MongoDB, não há recursos para transações e também joins, que são usados em 
bancos de dados relacionais, assim sendo, os desenvolvedores devem implementá-lo na 
aplicação quando for realmente necessário.
instalação e configuração
Entre outros sistemas de gerenciamento de banco de dados orientados ao NoSQL, o 
MongoDB possui uma certa vantagem em relação à simplicidade da instalação.
A instalação do MongoDB para Windows é centralizada, o protótipo será desenvolvido 
em uma plataforma direcionada a este sistema operacional. 
Primeiro, você deve acessar uma página de download no site oficial do software: <http://
www.mongodb.org/downloads>. É necessário escolher o elemento correto, de acordo 
com o sistema operacional e com o usuário utilizado. O site oferece tutoriais em inglês 
para instalar em outros sistemas operacionais.
Após o download do arquivo, no caso do MongoDB para Windows, basta executar o 
arquivo recebido para concluir a instalação. Os arquivos MongoDB serão colocados em 
um diretório em “C:”.
Por padrão, bancos, documentos e coleções são armazenados no arquivo C:\data\db, 
então você precisa criar esses diretórios se eles não existirem. No entanto, pode ser 
configurado para que os dados sejam armazenados em outro local de sua preferência. 
Para isso, é sempre necessário inicializar o servidor através de comando digitando o 
seguinte comando:
C:\mongodb\bin\mongod.exe --dbpath c:\novodir\db\data
Se você não tiver problemas para deixar o diretório inicial como coleções/documentos 
na raiz “C:”, basta executar o arquivo “mongod.exe” encontrado no diretório “bin”, 
dentro do diretório inicial do MongoDB criado em “C:”.
É sempre necessário rodar o executável mongod.exe para deixar o servidor on-line, ao 
fechá-lo, o servidor se desconecta automaticamente, ou seja, fica off-line. Na figura 20, 
é possível verificar a tela inicial ao executar o mongod.exe do servidor.
67
AtividAde PráticA │ UNidAde iv
Figura 20. tela servidor mongodB.
Fonte: mongodB (2016).
manipulação de dados
Após executar o arquivo do servidor, você pode abrir o cliente do MongoDB. Vá ao 
diretório “bin” e execute o arquivo mongo.exe.
Figura 21. cliente mongodB.
Fonte: mongodB (2016).
Na figura 21 vemos a tela exibida ao executar o cliente mongo.exe. Pode-se notar que 
somos automaticamente conectados ao banco de dados padrão nomeado “test”. 
68
UNIDADE IV │ AtIVIDADE PrátIcA
No MongoDB, não é necessário criar uma coleção para começarmos a inserir documentos 
e informações. Isto é feito automaticamente ao inserir o primeiro registro. 
Nas páginas seguintes, executaremos alguns comandos para a manipulação de dados. 
Então, sugiro que você acompanhe estes exemplos na prática, rodando tudo em sua 
máquina. 
Supondo que vamos criar o banco de dados “Faculdade”, e a coleção “Cursos” 
(comparando com um banco de dados relacional, “Cursos” é o equivalente a uma 
tabela), ao invés de executar um comando para criar a tabela, já podemos executar o 
comando de inserção de registros e o documento é criado automaticamente:
Figura 22. cliente mongodB.
Fonte: mongodB (2016).
O comando “use Faculdade” acessa o banco de dados “Faculdade” ou cria um banco de 
dados caso não exista nenhum outro banco com este nome, indicando também que os 
próximos comandos são referentes a esta base de dados. 
Figura 23. comando inserir.
Fonte: mongodB (2016).
69
AtividAde PráticA │ UNidAde iv
A figura 23 mostra os próximos comandos para inserir um novo registro na coleção 
“Cursos”. No caso, inserimos o curso “Ciências da Computação”. O comando foi 
montado com um array chamado “novo_curso” utilizando a sintaxe em JSON (em que 
o índice “nome” é equivalente a uma coluna de um banco de dados relacional), seguido 
do comando “db.cursos.save(novo_curso)”, no qual “cursos” será o nome da coleção e 
o parâmetro é a variável que armazena o registro a ser inserido. 
Nota-se que não foi feito nenhum comando para criar a coleção, apenas foi executado 
o comando de inserção. 
Figura 24. insert direto.
Fonte: mongodB (2016).
A figura 24 demonstra outra maneira de fazer a inserção, sem utilizar a variável de 
apoio “novo_curso”, passando como parâmetro para a função “save()” diretamente o 
array JSON de dados a ser inserido. 
Figura 25. consultar registros.
Fonte: mongodB (2016).
70
UNIDADE IV │ AtIVIDADE PrátIcA
Na figura 25, é possível ver o resultado do comando “db.cursos.find()”, que 
consulta todos os documentos (ou registros) da coleção “cursos”. Note que é criado 
automaticamente um atributo chamado “_id”. Este atributo cria um índice único para 
os registros, para que seja possível a edição ou exclusão de um registro específico. 
É basicamente um campo que armazena a hora da criação do registro e codifica tal 
dado em BSON. Para decodificar este dado, o MongoDB disponibiliza uma função 
chamada “getTimestamp()”, que retornará um objeto do tipo data como no exemplo: 
“ISODate(“2012-10-17T20:46:22Z”)”. 
Figura 26. remover.
Fonte: mongodB (2016).
Na figura 26, vemos o comando de exclusão “db.cursos.remove()”. Passamos por 
parâmetro o que seria o atributo where da linguagem SQL. Neste exemplo estamos 
excluindo todos os registros cujo atributo nome seja igual a “análise de sistemas”.
Figura 27. remover documento pelo atributo id.
Fonte: mongodB (2016).
71
AtividAde PráticA │ UNidAde iv
Na figura 27, tentamos excluir um documento pelo seu “_id”. Podemos observar o 
retorno “{“nRemoved” : 0}”, que indica que nenhum item foi excluído. Isto porque, 
como foi dito anteriormente, o índice “_id” armazena um objeto contendo a data em 
que o registro foi inserido, portanto para excluir o registro equivalente, temos que 
passar um objeto como parâmetro, como demonstrado na figura 26. 
Figura 28. remover atributo por “id” – ex. 2.
Fonte: mongodB (2016).
Na figura 28 passamos um “ObjetcId” como parâmetro e o retorno apontou para um 
registro excluído. Para apagar todos os registros de uma coleção, usamos o comando 
“db.cursos.drop()”.
Figura 29. exemplo de atualização.
Fonte: mongodB (2016).
Na figura 29, inserimos dois cursos, “Música” e “Administração”. Em seguida exibimos 
na tela. O comando “db.cursos.update()” atualizou o registro que continha o nome 
“administracao” para “administração”. 
Nos bancos de dados NoSQL não existem relacionamentos e caso seja necessário fazer 
uma relação entre os documentos (o que sairia um pouco do contexto de estar utilizando 
72
UNIDADE IV │ AtIVIDADE PrátIcA
um banco de dados não relacional), o usuário pode definir por exemplo, na coleção 
matéria, o índice “curso_id” e armazenar o valor do índice “_id” da coleção cursos, 
porém a consistência entre as tabelas terá de ser controlada por meio da programação. 
Em relações “muitos para muitos” ou “many to many”, é necessário criar um novo 
índice em ambas as coleções que irão se relacionar, contendo um array com os valores 
relacionados, como mostra o exemplo a seguir. 
Na figura 30, é exibida a lista de matérias sem a relação com alunos matriculados. 
Figura 30. listando documentos salvos na coleção matéria.
Fonte: mongodB (2016).
Será feito um update no documento desejado, adicionando um índicecom os alunos 
matriculados na devida disciplina, como veremos na figura 31.
Figura 31. criando “relação” de matérias com alunos.
Fonte: mongodB (2016).
Na figura 32, temos um exemplo de consulta neste índice que contém os alunos 
relacionados. 
Figura 32. consulta no índice formado por um array.
Fonte: mongodB (2016).
73
AtividAde PráticA │ UNidAde iv
No exemplo acima, foi realizado um update em outro documento da coleção matérias 
e exibidos os dados logo a seguir com o comando “db.materias.find()”. Para consultar, 
por exemplo, as matérias em que o aluno “Matheus” está matriculado, foi usado o 
comando “db.materias.find({“alunos” : “matheus”})”.Para que as mesmas consultas 
pudessem ser executadas na coleção alunos, seria necessário criar o índice “matérias” 
na coleção alunos assim como fizemos na coleção matérias para relacionar os alunos. 
Existem muitos outros comandos para consultas parecidos com comandos utilizados 
em SQL e podem ser encontrados no manual on-line do MongoDB.
desenvolvimento de um protótipo 
Para demonstrar o desenvolvimento utilizando o MongoDB como gerenciamento de 
banco de dados, será desenvolvido um protótipo utilizando a linguagem web PHP.
O protótipo consistirá em um cadastro de álbuns de música e além de uma versão 
utilizando o MongoDB, será desenvolvida uma versão utilizando PostgreSQL como 
banco de dados relacional, para fins de comparação de código. 
O protótipo se baseará em um formulário para o cadastro de álbuns no qual o usuário 
deverá digitar as músicas pertencentes ao álbum, o artista, os gêneros e a gravadora 
responsável, além de uma tela para consulta desses dados. 
A figura 33 mostra o formulário principal da aplicação. Os campos “Faixa” serão salvos 
na tabela “músicas” enquanto o restante das informações irá para a tabela “Álbum”. 
Figura 33. Formulário de cadastro.
Fonte: nascimento (2014).
74
UNIDADE IV │ AtIVIDADE PrátIcA
Figura 34. tela de consulta aos dados inseridos
Fonte: nascimento (2014).
modelagem dos dados 
Para a criação do banco de dados relacional, utilizando o PostgreSQL, foi feita a seguinte 
modelagem: 
Figura 35. modelagem do Banco de dados relacional.
Fonte: nascimento (2014).
Na tabela álbum, será realizado o relacionamento com as tabelas: gravadora, artista e 
gênero por uma chave estrangeira para cada uma dessas tabelas. Um álbum possuirá 
diversas músicas, por isso foi optado por deixar na tabela Músicas a chave estrangeira 
que relacionará o álbum a qual cada música pertence. 
Conectando PHP ao mongodB 
Para conectar o PHP ao MongoDB foi necessária a instalação de um driver. O link 
para o download do driver está disponível em “http://docs.mongodb.org/ecosystem/
75
AtividAde PráticA │ UNidAde iv
drivers/php”. Após o download, é necessário copiar o arquivo no diretório “ext” do 
servidor PHP e também acessar o arquivo de configuração “php.ini”, e acrescentar a 
linha “extension=php_mongo.dll”. Para ter certeza que o PHP consegue se conectar ao 
MongoDB, basta criar um arquivo PHP e utilizar o comando “phpinfo()”, no qual serão 
exibidos todos os dados do servidor e as extensões instaladas. 
Comparações no desenvolvimento do protótipo 
Para que a aplicação se conecte ao banco de dados relacional, no caso o PostgreSQL, 
é necessário criar um arquivo de configuração passando por parâmetro o host, porta, 
usuário e senha do banco de dados. Quando utilizamos o MongoDB, apenas é necessário 
inicializar a conexão, com a classe do PHP MongoClient, como vemos no exemplo abaixo: 
Figura 36. iniciando uma conexão do pHp com o mongodB.
Fonte: nascimento (2014).
A seguir, selecionaremos o banco de dados do MongoDB que desejamos manipular:
Figura 37. definindo o Banco de dados para manipulação.
Fonte: nascimento (2014).
Para criar uma nova coleção, utilizamos o seguinte comando: 
Figura 38. criando nova coleção de documentos.
Fonte: nascimento (2014).
Como podemos notar, o PHP tem classes prontas para manipular os dados com o 
MongoDB, o que torna mais fáceis as operações fundamentais: inserção, atualização, 
deleção e consulta. 
76
UNIDADE IV │ AtIVIDADE PrátIcA
Como exemplo, vamos analisar o formulário do protótipo (figura 33). Quando o botão 
“salvar” do formulário é pressionado, a aplicação executará um código em PHP. 
A seguinte query será montada por meio de uma string utilizando código PHP para que 
os dados do formulário sejam inseridos na tabela do banco de dados relacional: 
Figura 39. Query para postgresQl.
Fonte: nascimento (2014).
Para executar a query acima utilizando o PostgreSQL, o PHP possui um driver com 
classes para o uso deste banco de dados, assim como o MongoDB. Veja um exemplo de 
comando para a execução da query: 
Figura 40. exemplo de comando para execução da query.
Fonte: nascimento (2014).
O primeiro parâmetro é uma variável ($conexao) que armazena os dados da conexão 
com o banco de dados e a segunda ($sql_insert) é a query a ser executada. 
Para realizar a mesma operação utilizando o MongoDB, é necessário criar um array 
utilizando PHP para passar como parâmetro para a função de inserção. 
Para melhor entendimento, vejamos o trecho de código a seguir: 
Figura 41. configuração para conexão pHp ao postgresQl.
Fonte: nascimento (2014).
77
AtividAde PráticA │ UNidAde iv
A variável $conexao armazena o retorno da função “pg_connect”, e os parâmetros são 
os dados para acesso ao banco de dados. 
Existem frameworks que facilitam a criação das querys, mas como o foco deste 
estudo é o MongoDB, foi optado pela utilização do código PHP “puro”, até mesmo 
pois o MongoDB também possui módulos desenvolvidos na maioria dos frameworks 
para PHP. 
Figura 42. array parâmetro para inserção no mongodB.
Fonte: nascimento (2014).
Note que temos um índice “musicas”. Diferentemente do banco de dados relacional, 
o MongoDB não possui a operação JOIN, mas podemos salvar em um documento 
um array como valor de uma coluna, podendo assim “substituir” a tabela “músicas” 
do modelo relacional, e vincular a um álbum um array de músicas. Além disso, é 
necessário alterar os valores que o formulário passará nos casos de gênero, artista 
e gravadora. No modelo relacional, o valor passado ao PHP para montar a query 
de inserção é o valor da chave primária de cada uma dessas tabelas para que seja 
criado o relacionamento com a tabela álbum. No MongoDB, por não haver JOINS e 
relacionamentos, foi alterado o valor enviado pelo formulário para o campo nome, 
gravando no nosso documento uma string. 
Se caso o usuário desejasse criar novas colunas para a tabela “Gravadora”, por exemplo, 
a maneira mais apropriada de reproduzir este caso para o MongoDB seria criar um novo 
índice contendo um array com as chaves equivalentes às colunas desejadas e armazenar 
em um índice “gravadoras”, assim como foi feito para o caso das músicas. 
Para outras operações como consultar, editar e remover, o processo para o 
desenvolvimento em PHP seria idêntico ao comando de insert, em que será necessário 
criar uma string e executá-la com a classe do PostgreSQL. 
78
UNIDADE IV │ AtIVIDADE PrátIcA
Para realizar uma atualização em algum documento de uma coleção, utilizamos em 
PHP o código a seguir: 
Figura 43. update com mongodB.
Fonte: nascimento (2014).
O primeiro parâmetro para a função update é o equivalente a expressão where da 
linguagem SQL, no qual indicamos a condição para que o documento seja atualizado. 
O segundo parâmetro é um array contendo as informações atualizadas, assim como foi 
feito para a inserção. 
O comando para exclusão é idêntico ao de atualização: 
Figura 44. remover registro com mongodB.
Fonte: nascimento (2014).
Para realizar uma consulta aos documentos de determinada coleção, utilizamos a função 
“find()”. Caso seja necessário um filtro, basta passar um parâmetro de comparação, 
assim como fazemos nas operações update e remove. 
Figura 45. exemplos de consulta com mongodB.
Fonte: nascimento (2014).
Existem outras funções para consulta,como “limit()”, que limitará o número de 
documentos retornados. 
O foco do estudo não era comparação de desempenho, portanto, não foram utilizados 
softwares para medir o desempenho das consultas. 
79
CAPítulo 2
gridfS!
Digamos que temos uma aplicação hospitalar média que faz a gravação dos dados dos 
seus pacientes. Assim como a lógica de computação, cada pessoa tem uma representação 
em um conjunto de metadados (nome, sobrenome, endereço, CPF, entre outros) e 
outros arquivos, como por exemplo, os resultados da consulta ou exame. Com isso já 
notamos que é gerado um grande volume de dados.
E uma decisão importante é necessária a se tomar, manter todos os dados em um único 
gerenciador de banco de dados? Ou jogar essa responsabilidade ao sistema operacional, 
que irá gerenciar esses grandes arquivos?
O MongoDB tem a possibilidade de reunir grandes volumes de dados apresentando 
características bem diversas (imagens, vídeos, entre outros). Pasmem! A grande 
vantagem é que teríamos uma administração bastante simples. Não estaríamos sujeitos 
às limitações do sistema operacional no que tange à gerência de milhões de arquivos 
e ainda poderíamos implementar técnicas sofisticadas, tais como particionamento e 
replicação (DataScience, 2016).
E onde usamos o recurso GridFS? Exatamente agora! Para lidar com grandes arquivos, 
o MongoDB possui esse recurso denominado de GridFS, que é utilizado quando 
queremos armazenar arquivos com tamanho superior a 16 MB (DataScience, 2016). 
Em tese, podemos gravar arquivos menores diretamente em campos do tipo binário 
(binary data), porém, neste caso, devemos criar pequenos programas (escrito em 
alguma linguagem de programação, tal como Python, C++, PHP, NodeJS etc.).
Vale lembrar que um banco de dados MongoDB é feito por diversas coleções e estas 
por conjuntos de documentos, que podem ter suas estruturas diferentes. Ainda que 
façamos a interação utilizando estruturas JSON, o MongoDB armazena internamente 
os dados utilizando um padrão proprietário denominado BSON (binary JSON). Assim, 
tudo é armazenado de forma binária e não apenas grandes arquivos.
Vamos analisar agora um caso prático. Digamos que seja necessário armazenar em um 
banco de dados MongoDB uma relação de músicas (arquivos mp3):
80
UNIDADE IV │ AtIVIDADE PrátIcA
Figura 46. relação de músicas.
Fonte: datascience (2016).
Poderíamos reunir algumas músicas criando uma espécie de playlist:
copy /b AllAboutThatBass.mp3 + AmIWrong.mp3 + Budapest.mp3 + 
NoWayNo.mp3 + TheWeeknd.mp3 Trilha.mp3
Vamos checar agora o tamanho do arquivo resultante:
Figura 47. playlist de músicas: trilha.mp3.
Fonte: datascience (2016).
Assumindo que tenhamos um servidor MongoDB disponível, o comando a seguir faria 
a carga do arquivo Trilha.mp3:
81
AtividAde PráticA │ UNidAde iv
Figura 48. carga do arquivo trilha.mp3.
Fonte: datascience (2016).
Observações:
 » O arquivo será carregado no banco de dados chamado Musicas (observe 
a opção -d). Caso este banco não exista, será criado;
 » O utilitário mongofiles trabalha com três tipos de argumentos: opções 
(no exemplo: --host e -d); comando (por exemplo, put) e; nome de 
arquivo (mp3).
Caso o arquivo carregado possua mais que 16 MB, internamente ele será dividido em 
pequenas porções denominadas chunks.
No banco de dados de destino serão criadas duas coleções: fs.files e fs.chunks. 
A primeira terá um documento para cada arquivo importado, enquanto que a 
segunda comportará a relação de chunks. Vale notar a ocorrência de uma espécie de 
relacionamentos entre as coleções, já que o conteúdo do atributo _id da coleção mãe 
será repetido em tantos documentos quanto chunks existirem representados na coleção 
filha (atributo files_id).
Podemos mostrar os arquivos e seus respectivos chunks realizando uma junção entre 
as coleções. No MongoDB, consultas desta natureza utilizam agregação. Por exemplo:
db.fs.files.aggregate (
[ {
$lookup:
{
from: “fs.chunks”,
localField: “_id”,
foreignField: “files_id”,
as: “relacionado”
}
}
] )
82
UNIDADE IV │ AtIVIDADE PrátIcA
Observações:
 » O método aggregate recebe uma lista de operadores, tais como: $group, 
$match ou $sort. No exemplo acima estamos utilizando apenas o 
operador $lookup;
 » Para realizar a junção, precisamos informar a coleção filha (chunks), o 
atributo na coleção mãe atuando como chave primária (_id), o atributo 
na coleção filha atuando como chave estrangeira (files_id) e um nome 
para o vetor que conterá a relação de documentos filhos (relacionado).
Caso o vetor seja muito extenso, podemos receber o seguinte erro:
 » assert: command failed: { “ok” : 0, “errmsg” : “Total size of documents in 
fs.chunks matching { files_id: { $eq: ObjectId(’57b5f49412042f328c2ce
b92′) } } exceeds maximum document size”, “code” : 4568} : aggregate 
failed _getErrorWithCode@src/mongo/shell/utils.js:23:13doassert@
src/mongo/shell/assert.js:13:14assert.commandWorked@src/mongo/
shell/assert.js:264:5 DBCollection.prototype.aggregate@src/mongo/
shell/collection.js:1215:5@(shell):1:1
Para contornar esse problema, precisamos desmembrar o vetor em vários documentos. 
Isto pode ser obtido utilizando outro operador de agregação, o $unwind:
db.fs.files.aggregate (
[ {
$lookup:
{
from: “fs.chunks”,
localField: “_id”,
foreignField: “files_id”,
as: “relacionado”
}
},
{“$unwind”:
83
AtividAde PráticA │ UNidAde iv
{“path”: “$relacionado”,
 “preserveNullAndEmptyArrays”: true
}
}
 ] )
Perceba como tivemos que mencionar o vetor no campo path.
Executando a consulta acima em um ambiente gráfico como o Robomongo3, teríamos 
a seguinte saída:
Figura 49. saída de execução no robomongo.
Fonte: datascience (2016).
O exemplo acima mostra tantos documentos quanto chunks houver. A única diferença 
entre os documentos mostrados está na última coluna, exibindo um subdocumento 
com os quatro campos da coleção fs.chunks.
3 O Robomongo é um software multiplaforma para gerenciamento de bancos de dados MongoDB, podendo ser instalado em 
Windows, Mac e Linux.
84
UNIDADE IV │ AtIVIDADE PrátIcA
Mesmo o arquivo tendo um tamanho inferior a 16 MB, ainda assim podemos utilizar 
o GridFS. Nestes casos, entretanto, nenhum documento será criado na coleção 
fs.chunks. 
Mas se o cenário mudar e desejarmos adicionar mais um arquivo mp3 ao nosso banco 
de dados musical, porém desta vez sem fazer parte de uma playlist, devemos executar 
o comando:
mongofiles --host localhost -d Musicas put Photograph.mp3
O comando a seguir lista os arquivos carregados:
Figura 50. listagem dos arquivos carregados.
Fonte: datascience (2016).
Poderíamos, eventualmente, recuperar um arquivo carregado e trazê-lo novamente aos 
cuidados do sistema operacional. Para isto, precisamos do comando get: 
mongofiles --host localhost --local P.mp3 -d Musicas get Photograph.mp3
85
referências
Data Science Academy. Publicado em 2016. Disponível em: <http://
datascienceacademy.com.br/blog/gridfs-gerenciando-big-data-em-mongodb/>. 
Acessado em: 15 de janeiro 2018.
KORTH, Henry F., SILBERSCHATZ, Abraham. Sistema de Banco de Dados. 2. ed. 
rev. São Paulo: Makron Books, 1995.
KYLE; B. MongoDB. In: Action. Manning, 2011.
MICROSOFT. BD Cosmos do Azure. Disponível em: <https://azure.microsoft.com/
pt-br/services/cosmos-db/>. Acessado em: 30 de novembro de 2017.
MONGODB. Explore o MongoDB. Disponível em: <http://www.ibm.com/
developerworks/br/library/os-mongodb4>. Acessado em: 27 de outubro de 2017.
NASCIMENTO, Bellio. MongoDB: Um estudo teórico-prático do conceito de banco de 
dados NoSQL, Faculdade Campo Limpo Paulista, 2014.
PEARSON. Sams Teach Yourself NoSQL with MongoDB in 24 Hours. 
Disponível em: <http://ptgmedia.pearsoncmg.com/imprint_downloads/informit/
learninglabs/9780133902990/ch02.html>. Acessado em: 26 de novembro de 2017.
SANTOS, José, I. Plataforma para Gestão e Monitorização de Eventos. Dissertação 
de Mestrado. Universidade do Algarve, Portugal. 2014.
	_ftnref1