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
ModelageM