See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/272887058

MongoDB: Um Estudo Teórico-Prático do Conceito de Banco de Dados NoSQL -

Trabalho de Diplomação

Thesis · December 2014

CITATION READS

1 7,375

2 authors, including:

Computação Unifaccamp
Faculdade Campo Limpo Paulista
38 PUBLICATIONS   1 CITATION   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Laboratório de engenharia e produção de software Faccamp View project

Metodologia e Orientação de Trabalho de Pesquisa em Computação (Faccamp) View project

All content following this page was uploaded by Computação Unifaccamp on 28 February 2015.

The user has requested enhancement of the downloaded file.

 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Trabalho de Diplomação

Matheus Bellio Nascimento – 11025

André Marcos Silva(Orientador)

Trabalho de Diplomação

MongoDB: Um Estudo Teórico-

Prático do Conceito de Banco de
Dados NoSQL
Matheus Bellio Nascimento
 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Mongo DB: Um estudo teórico-prático do conceito de banco de

dados NoSQL

Trabalho submetido à Coordenação de

Ciência da Computação da Faculdade Campo
Limpo Paulista como requisito parcial para
obtenção do título de Bacharel em Ciência da
Computação.
Campo Limpo Pta (SP), 12 de dezembro de
2014.

Matheus Bellio Nascimento

Banca examinadora
Prof. Me. André Marcos Silva (Orientador)
Prof. Dr. Luis Mariano del Val Cura
Prof. Dr. Osvaldo Luís de Oliveira (Suplente)

2
 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Mongo DB: Um estudo teórico-prático do conceito de

banco de dados NoSQL

Dedicatória

Este trabalho é dedicado a todos os professores e demais cidadãos que

compartilham conhecimento, não só para a área de computação, e também a todos
aqueles que buscam pelo conhecimento.

3
 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Mongo DB: Um estudo teórico-prático do conceito de

banco de dados NoSQL

Agradecimentos

Primeiramente à minha família pela educação e apoio e incentivo para todos os

desafios da vida.

Ao professor André Marcos Silva por toda orientação e suporte para que este
trabalho fosse concluído.

À minha namorada Ana Helena pelo incentivo, e a todos os amigos feitos durante
o curso por tornarem o ensino mais divertido.

4
 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Mongo DB: Um estudo teórico-prático do conceito

de banco de dados NoSQL

RESUMO
Neste trabalho, será realizado o desenvolvimento de um protótipo na linguagem
de programação PHP, utilizando um banco de dados não relacional (NoSQL) -
que será gerenciado pela aplicação MongoDB – para o estudo e comparação de
banco de dados relacional e não-relacional, fazendo uma breve comparação e
análise dos métodos utilizados em ambos os casos para o desenvolvimento da
aplicação.

5
 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Mongo DB: Um estudo teórico-prático do conceito de

banco de dados NoSQL

SUMÁRIO
1. INTRODUÇÃO .............................................................................................. 8
2. O PROBLEMA ............................................................................................... 9
3. OBJETIVOS ................................................................................................... 9
4. METODOLOGIA ........................................................................................... 9
5. REFERENCIAL TEÓRICO ........................................................................... 9
Banco de dados ................................................................................................... 9
Modelo Relacional ............................................................................................ 10
Modelo de Rede ................................................................................................ 12
Modelo Hierárquico .......................................................................................... 12
SQL – Structured Query Language ................................................................... 13
NoSQL (Banco de dados não relacional) .......................................................... 13
6. ATIVIDADE PRÁTICA ............................................................................... 14
MongoDB.......................................................................................................... 14
Instalação e Configuração ................................................................................. 15
Manipulação de dados ....................................................................................... 16
Desenvolvimento de Protótipo .......................................................................... 22
Modelagem de Dados ........................................................................................ 23
Conectando PHP ao MongoDB ........................................................................ 24
Comparações no desenvolvimento do protótipo ............................................... 24
Resultados obtidos ............................................................................................ 28
7. CONCLUSÕES ............................................................................................ 29
8. REFERÊNCIAS BIBLIOGRÁFICAS .......................................................... 30

6
 FACULDADE CAMPO LIMPO PAULISTA
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Mongo DB: Um estudo teórico-prático do conceito de

banco de dados NoSQL

INDÍCE DE FIGURAS
Figura 1 - Banco de Dados Relacional .................................................................. 11
Figura 2 - Modelo de Rede.................................................................................... 12
Figura 3 - Modelo Hierárquico ............................................................................. 13
Figura 4 - Tela Servidor MongoDB ...................................................................... 16
Figura 5 - Cliente MongoDB ................................................................................ 17
Figura 6 - Criando um Banco de Dados ................................................................ 17
Figura 7 - Comando Inserir ................................................................................... 18
Figura 8 - Insert Direto .......................................................................................... 18
Figura 9 - Consultar Registros .............................................................................. 19
Figura 10 - Remover ............................................................................................. 19
Figura 11 - Remover documento pelo atributo ID ................................................ 20
Figura 12 - Remover Atributo por “Id” - Exemplo 2 ............................................ 20
Figura 13 - Exemplo de Atualização ..................................................................... 21
Figura 14 - Formulário de Cadastro ...................................................................... 23
Figura 15- Tela de Consulta aos Dados Inseridos ................................................. 23
Figura 16 - Modelagem do Banco de Dados Relacional....................................... 24
Figura 17- Iniciando uma conexão do PHP com o MongoDB ............................. 25
Figura 18- Definindo o Banco de Dados para manipulação ................................. 25
Figura 19- Criando nova coleção de documentos ................................................. 25
Figura 20 - Query para PostgreSQL...................................................................... 25
Figura 21 - Exemplo de comando para execução da query .................................. 26
Figura 22 - Configuração para conexão PHP ao PostgreSQL .............................. 26
Figura 23 - Array parametro para inserção no MongoDB .................................... 27
Figura 24 - Update com MongoDB ...................................................................... 27
Figura 25 - Remover registro com MongoDB ...................................................... 28
Figura 26 - Exemplos de consulta com MongoDB ............................................... 28

7
1. INTRODUÇÃO
Historicamente, o modelo de dados relacionais tem sido o mais utilizado por
Sistemas de Gerenciamento de Banco de Dados, inclusive nos dias de hoje.
Porém, atualmente, devido ao crescimento de aplicações que geram grande
volume de dados e consequentemente necessitam servir a muitos usuários, o
modelo relacional de banco de dados mostrou algumas deficiências, como
questões de escalabilidade horizontal (inclusive por não ter sido inicialmente
projetado em torno desta ideia), portanto sistemas que utilizam bancos de dados
relacionais acabam por realizar escalabilidade vertical, ou seja, quando o
desempenho do sistema necessita ser otimizado, faz-se upgrades ou melhorias dos
hardwares do servidor em que a aplicação se encontra. Porém a escalabilidade
vertical é limitada, portanto pela necessidade de escalabilidade sem perda de
desempenho, surgiram opções ao modelo relacional, uma delas o NoSQL.
O termo NoSQL foi utilizado pela primeira vez em 1998, como um banco de
dados relacional de código aberto que não possuía interface SQL. "O movimento
NoSQL é completamente distinto do modelo relacional e portanto deveria ser
mais apropriadamente chamado "NoREL" ou algo que produzisse o mesmo
efeito" (Strozzi, 2007). Somente em 2009 o termo foi reintroduzido em um evento
que visava discutir banco de dados open source distribuídos, promovido por Johan
Oskarsson. Posteriormente surgiram projetos NoSQL como MongoDB, CouchDB
e Cassandra (Evans, 2009).
Para este trabalho, será instalado e configurado um servidor utilizando os recursos
do MongoDB, que é um dos gerenciadores que utilizam NoSQL, e também será
desenvolvido um protótipo para comparação e análise dos métodos utilizados para
o desenvolvimento com um banco de dados relacional e banco de dados não
relacional.
Este trabalho está atualmente organizado da seguinte forma: na seção 2 está a
argumentação justificativa sobre a realização do trabalho, na seção 3 estão
propostos os objetivos a serem trabalhados, na seção 4 são esboçados os
procedimentos e metodologias que serão executados. Na seção 5 estão
apresentados panoramas das principais tecnologias envolvidas para a realização
deste trabalho, na seção 6 é apresentado o desenvolvimento do trabalho, contendo
justificativas das escolhas das ferramentas utilizadas, a apresentação do projeto
realizado e também os resultados obtidos na realização deste projeto. Na seção 7
são esboçadas as conclusões encontradas durante a realização deste trabalho,
como também os benefícios adquiridos ao ser realizado. Ao final, na seção 8,
estão indicadas as referências bibliográficas organizadas neste trabalho.

8
2. O PROBLEMA
Muitas das grandes empresas de software (Google, Facebook, Twitter, Amazon),
estão utilizando este método de gerenciamento de dados, e aparentemente obtendo
sucesso, o que comprova que a utilização de banco de dados não relacionais será
uma tendência em soluções para aplicações que necessitaram de manipulação de
grande quantidade de dados e escalabilidade.
No entanto é necessário um estudo para compreender em quais casos é vantajosa a
utilização de tal tecnologia, para que seus recursos sejam aproveitados em sua
totalidade.

3. OBJETIVOS
O objetivo deste trabalho será o estudo de um sistema de gerenciamento de banco
de dados NoSQL, para entendimento e comparação com banco de dados
relacionais, dando demonstrações de utilização do NoSQL em códigos de
programação, dando uma visão aos desenvolvedores de como implantar este
método em seus sistemas.

4. METODOLOGIA
Será realizado o estudo de um gerenciador de banco de dados NoSQL, tendo
como critério softwares open source, dentre os mais populares, levando em conta
a facilidade para encontrar documentações. Analisando estes critérios, foi definido
que será utilizada a ferramenta MongoDB.
Uma aplicação com operações CRUD (create, read, update, delete) será
desenvolvida, utilizando o gerenciador não-relacional escolhido afim de
demonstrar seus recursos e sintaxes para programação, e também com um módulo
utilizando banco de dados relacional, para comparações de código e estrutura,
analisando as diferenças e dificuldades que um desenvolvedor poderá encontrar na
criação ou migração de um SGBD (Sistema de Gerenciamento de Banco de
Dados) relacional para um não-relacional.

5. REFERENCIAL TEÓRICO

Banco de dados
“Um banco de dados é uma coleção de dados persistente usada pelos sistemas de
aplicação de uma determinada empresa” (Date,2003).
Em outras palavras, um banco de dados é um ambiente, computacional ou não, no
qual é armazenada uma série de informações interligadas, que tem alguma relação
com um determinado ambiente, como uma empresa.

9
Segundo Korth, Silberschatz e Sudarshan (1999), “Um Sistema Gerenciador de
Banco de Dados (SGBD) é constituído por um conjunto de dados associados a um
conjunto de programas para acesso a esses dados. O conjunto de dados,
comumente chamado banco de dados, contém informações sobre uma empresa em
particular. O principal objetivo de um SGBD é proporcionar um ambiente tanto
conveniente quanto eficiente para a recuperação e armazenamento das
informações do banco de dados”.
Podemos afirmar então, que um Sistema Gerenciador de Banco de Dados é uma
ferramenta para abstração de dados ou consulta e manipulação das informações
contidas em um banco de dados.

Modelo Relacional
Um banco de dados que segue o modelo relacional é um banco de dados, que
toma como principio a afirmação de que todas as informações estão armazenadas
em tabelas (ou formalmente, relações).
O conceito modelo relacional foi criado por Edgar Frank Codd. Segundo Codd
(1985), existem 13 regras para que um banco de dados seja considerado
relacional:

1. Regra Fundamental: um SGBD relacional deve gerir os seus dados usando

apenas suas capacidades relacionais.

2. Regra da informação: toda informação deve ser representada de uma única

forma: como dados em uma tabela.

3. Regra de acesso garantido: todo o dado (valor atómico) pode ser acedido
logicamente (e unicamente) usando o nome da tabela, o valor da chave
primária da linha e o nome da coluna.

4. Tratamento sistemático de valores nulos: os valores nulos (diferente do

zero, da string vazia, da string de caracteres em brancos e outros valores
não nulos) existem para representar dados não existentes de forma
sistemática e independente do tipo de dado.

5. Catálogo on-line baseado no modelo relacional: a descrição do banco de

dados é representada no nível lógico como dados ordinários (isto é, em
tabelas), permitindo que usuários autorizados apliquem as mesmas formas
de manipular dados aplicados aos dados comuns ao consultá-las.

6. Sub linguagem abrangente: um sistema relacional pode suportar várias

linguagens e formas de uso, porém deve possuir ao menos uma linguagem
com sintaxe bem definida e expressa por cadeia de caracteres e com
habilidade de apoiar a definição de dados, a definição de visões, a
manipulação de dados, as restrições de integridade, a autorização e a
fronteira de transações.

10
 7. Regra da atualização de visões: toda visão que for teoricamente atualizável
será também atualizável pelo sistema.

8. Inserção, atualização, e exclusão de alto nível: qualquer conjunto de dados

que pode ser manipulado com um único comando para retornar
informações, também deve ser manipulado com um único comando para
operações de inserção, atualização e exclusão. Simplificando, significa
dizer que as operações de manipulação de dados devem poder ser
aplicadas a várias linhas de uma vez, ao invés de apenas uma por vez.

9. Independência dos dados físicos: programas de aplicação ou atividades de

terminal permanecem logicamente inalteradas quaisquer que sejam as
modificações na representação de armazenagem ou métodos de acesso
internos.

10. Independência lógica de dados: programas de aplicação ou atividades de

terminal permanecem logicamente inalteradas quaisquer que sejam as
mudanças de informação que permitam teoricamente a não alteração das
tabelas base.

11. Independência de Integridade: as relações de integridade específicas de um

banco de dados relacional devem ser definidas em uma sub linguagem de
dados e armazenadas no catálogo (e não em programas).

12. Independência de distribuição: a linguagem de manipulação de dados deve

possibilitar que as aplicações permaneçam inalteradas estejam os dados
centralizados ou distribuídos fisicamente.

13. A não transposição das regras: se o sistema relacional possui uma

linguagem de baixo nível (um registro por vez), não deve ser possível
subverter ou ignorar as regras de integridade e restrições definidas no alto
nível (muitos registros por vez).

Na figura 1 (Neto, 2008) apresentada abaixo, temos uma representação de tabelas

de um banco de dados relacional:

Figura 1 - Banco de Dados Relacional

11
A tabela “Empregado” possui um relacionamento com a tabela departamento
através do campo “Dept”, que possui como valor um código que é originado da
tabela “Departamento” no campo “NumDept”, possibilitando então, por este
campo em comum, que o banco de dados consiga buscar informações dos demais
campos da tabela “Departamento”.
Historicamente, o modelo relacional é o sucessor do modelo de redes e do modelo
hierárquico.

Modelo de Rede
“Os dados no modelo de rede são representados por um conjunto de registros e as
relações entre estes registros são representadas por links (ligações), as quais
podem ser vistas pelos ponteiros. Os registros são organizados no banco de dados
por um conjunto arbitrário de gráficos” (Korth et al ,1999). A figura 2 (Neto,
2008) apresenta um exemplo de banco de dados em rede:

Figura 2 - Modelo de Rede

Como vemos no modelo acima, os registros, diferente do banco de dados
relacional, não possuem campo em comum. As ligações são feitas por ponteiros
que determinam quais registros estão relacionados. Um registro “filho” (no
exemplo, a tabela “Departamento”) pode estar relacionado a mais de um registro
“pai” (tabela “Empregado” neste exemplo).

Modelo Hierárquico
“O modelo hierárquico é similar ao modelo em rede, pois os dados e suas relações
são representados, respectivamente, por registros e links. A diferença é que no
modelo hierárquico os registros estão organizados em árvores em vez de em
gráficos arbitrários” (Korth et al ,1999).

12
 Figura 3 - Modelo Hierárquico
No modelo hierárquico demonstrado pela figura 3 (Neto, 2008), diferentemente
do modelo em rede, os registros “filhos” não podem ser ligados diretamente a
mais de um registro “pai”, o relacionamento é feito através de hierarquia, em uma
estrutura de dados em árvore.

SQL – Structured Query Language

SQL – uma sigla para “Structured Query Language”, em português “linguagem
de consulta estruturada”, é uma linguagem criada para consultas e manipulações
de dados, através de um SGBD (Sistema de Gerenciamento de Banco de Dados),
em banco de dados relacionais. A linguagem SQL surgiu em 1974 e foi
desenvolvida por Edgar Frank Codd nos laboratórios da IBM para um sistema
chamado SYSTEM R.
As principais operações da linguagem SQL são: insert (inserção), update
(atualização), delete (exclusão) e select (consulta). A linguagem SQL é utilizada
para criar as relações entre as tabelas dentro de um banco de dados, e também
controlar e manipular o acesso aos dados, através de registros (ou tuplas).

NoSQL (Banco de dados não relacional)

Um modelo relacional apresenta os dados para o usuário apenas em tabelas e nada
mais além de tabelas. Já os bancos de dados não-relacionais, utilizam outras
estruturas para a representação dos dados e também outros métodos para acesso a
estes dados.
O termo NoSQL, interpretado como “Not Only SQL” (não apenas SQL), foi
utilizado pela primeira vez em 1998, por Calor Strozzi como um banco de dados
relacional de código aberto que não possuía interface SQL. Strozzi dizia que o
movimento NoSQL era completamente do modelo relacional e por isso seu nome
poderia ser mais apropriadamente “NoREL” (não relacional).
O NoSQL surgiu da necessidade de aprimorar a performance de aplicações e
sistemas ao lidar com grande quantidade de dados, pois o modelo relacional
apresenta certas dificuldades nas questões de escalabilidade.
Nos bancos de dados NoSQL, as informações são agrupadas num único registro,
sem a necessidade de relacionar várias tabelas para obter uma informação. Além

13
disse, existem dentro do NoSQL, algumas subdivisões de acordo com a forma que
será utilizada para o armazenamento de dados.
Algumas destas subdivisões são: Key/Value Store, Wide Column Store, Document
Store, e Graph Databases:
1. Key/Value Store: esse é o tipo de banco de dados NoSQL mais simples, o
conceito dele é uma chave e um valor para essa chave. Mas ele é o que
aguenta mais carga de dados. Estes tipos de banco de dados é o que possui
maior escalabilidade.
2. Wide Column Store: fortemente inspirados pelo BigTable, do Google, eles
suportam várias linhas e colunas além de permitir sub colunas.
3. Document Store: baseado em documentos XML ou JSON, podem ser
localizados pelo seu id único ou por qualquer registro que tenha no
documento.
4. Graph Store: com uma complexidade maior, esses bancos de dados
guardam objetos, e não registros como os outros tipos de NoSQL. A busca
desses itens é feita pela navegação desses objetos.

6. ATIVIDADE PRÁTICA

MongoDB
O MongoDB é um banco de dados NoSQL de código aberto sob a licença GNU
AGPL v3.0, escrito em C++, orientado a documentos e livre de schemas. Seu
nome é derivado da expressão em inglês humongous, que pode ser traduzido como
“enorme” ou “monstruoso”.
O MongoDB inicialmente foi desenvolvido como um componente de serviço pela
empresa 10gen em outubro de 2007, passando a ser um software open source em
2009. Atualmente, o MongoDB é um dos mais populares banco de dados NoSQL
(senão o mais popular) e está na versão 2.6. O projeto ainda é mantido pela 10gen
que oferece suporte comercial e demais serviços.
O principal diferencial para que o MongoDB tenha se tornado mais popular que
outros Sistemas de Gerenciamento de Banco de Dados NoSQL, talvez seja a
facilidade na instalação.
O MongoDB é composto por dois serviços: mongod e mongos. O mongos é
usado para autosharding. Sharding é a distribuição física de dados em nós
distintos, utilizado quando é necessário o balanceamento de carga.
O mongod é o servidor de banco de dados. É altamente recomendado que o
mongod seja executado em um sistema operacional 64 bits, uma vez que o
tamanho máximo para um banco de dados numa arquitetura de 32 bits é de 2
gigabytes.

14
Além do servidor, o MongoDB possui um serviço cliente shell padrão, o mongos,
que é utilizado para a conexão com o servidor através da porta 27017, mas além
deste cliente, estão disponíveis diversos drivers oficiais para linguagens como
PHP, JAVA, C, C++, entre outros.
O servidor de MongoDB pode armazenar um ou mais banco de dados distintos,
onde cada banco de dados é constituído de uma ou mais coleções e cada coleção
pode ter um ou mais documentos. Estes documentos são estruturados como
documentos JSON e armazenados no formato BSON (Binary JSON).
JSON (JavaScript Object Notation), é uma estrutura de dados criada em
javascript, consistindo no padrão atributo/valor, parecido com arrays. O JSON
pode ser uma alternativa ao XML, onde por vezes se sobressai no questão de
velocidade de leitura dos dados nele armazenados.
Exemplo de estrutura JSON:
{“nome”: “joao”, “idade” : “20”}, {“nome”: “maria”, “idade” : “22”}.

Em uma breve comparação com o modelo relacional, coleções são equivalentes a

tabelas e documentos equivalentes a tuplas(ou linhas) que são armazenados na
tabela.
As consultas aos dados são feitas a partir da sintaxe JSON e enviadas para o
servidor através de drivers no formato BSON, onde neste modelo, é possível
buscar informações em todos os documentos de uma coleção.
No MongoDB, não existem recursos para transações e também joins, que são
muito utilizados em banco de dados relacionais, ficando por responsabilidade dos
desenvolvedores implementar na aplicação caso seja realmente necessário.

Instalação e Configuração
Dentre a outros Sistemas de Gerenciamento de Banco de Dados voltados a
NoSQL, o MongoDB leva certa vantagem quanto a simplicidade de instalação.
Neste tópico será focado a instalação do MongoDB para Windows pois o
protótipo será desenvolvido em uma plataforma voltada para este sistema
operacional. Vale frisar que o MongoDB requer que a versão do Windows seja
superior a versão do Windows XP.
Primeiramente, deve-se acessar a página de downloads no site oficial do software:
http://www.mongodb.org/downloads. Deve-se escolher o item correto,
dependendo do sistema operacional que o usuário utiliza. O site disponibiliza
tutoriais em inglês para instalação nos demais sistemas operacionais.
Após o download do arquivo, no caso MongoDB pra Windows, basta executar o
arquivo recebido para que a instalação seja concluída. Os arquivos do MongoDB
ficarão em um diretório em “C:”.

15
Por padrão, os bancos, documentos e coleções serão armazenados no diretório
C:\data\db, portanto é necessário criar estes diretórios caso não existam. Porém, é
possível configurar para que os dados sejam armazenados em outro diretório de
preferência. Para isso, é necessário sempre inicializar o servidor via prompt de
comando do Windows digitando o comando a seguir:
C:\mongodb\bin\mongod.exe --dbpath c:\novodir\db\data

Caso não tenha problemas em deixar o diretório base para armazenamento de

coleções/documentos na raiz do “C:”, basta executar o arquivo “mongod.exe”
encontrado no diretório “bin”, dentro do diretório base do MongoDB criado em
“C:”.
É necessário sempre executar o executável mongod.exe para que o servidor fique
online, ao fecha-lo o servidor ficará off-line automaticamente.

Figura 4 - Tela Servidor MongoDB

Na figura 4, podemos ver a tela exibida ao executar o arquivo mongod.exe, que
inicializa o servidor.

Manipulação de dados
Para abrir o cliente do MongoDB, basta executar o arquivo mongo.exe encontrado
no diretório “bin”.

16
 Figura 5 - Cliente MongoDB

Na imagem 5 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”.
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.
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 6 - Criando um Banco de Dados

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.

17
 Figura 7 - Comando Inserir
A figura 7 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
(onde o índice “nome” é equivalente a uma coluna de um banco de dados
relacional), seguido do comando “db.cursos.save(novo_curso)”, onde “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 8 - Insert Direto

A figura 8 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.

18
 Figura 9 - Consultar Registros

Na figura 9, é 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 de codificar 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 10 - Remover
Na figura 10, 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 “analise de
sistemas”.

19
 Figura 11 - Remover documento pelo atributo ID
Na figura 11, 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 que o registro foi inserido, portanto para excluir o registro equivalente,
temos que passar um objeto como parâmetro, como demonstrado na figura 12.

Figura 12 - Remover Atributo por “Id” - Exemplo 2

Na figura 12 passamos um “ObjetcId” como parâmetro e o retorno apontou para 1

registro excluído.
Para apagar todos os registros de uma coleção, usamos o comando
“db.cursos.drop()”;

20
 Figura 13 - Exemplo de Atualização

Na figura 13, 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 necessário fazer
uma relação entre os documentos (o que sairia um pouco do contexto de estar
utilizando 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 através
de 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 14, é exibido a lista de matérias sem a relação com alunos matriculados.

Figura 14 - Listando documentos salvos na coleção matéria

Será feito um update no documento desejado, adicionando um índice com os
alunos matriculados na devida disciplina, como veremos na figura 15.

Figura 15 - Criando "relação" de matérias com alunos

Na figura 16, temos um exemplo de consulta neste índice que contem os alunos
relacionados.

21
 Figura 16 - Consulta no índice formado por um array
No exemplo acima, foi realizado um update em outro documento da coleção
matérias e exibido 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”})”.
Nos exemplos da figura 15 e da figura 16, fizemos consultas na coleção matérias.
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 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á desenvolvido 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 onde 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 14 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ão para a tabela
“Álbum”.

22
 Figura 17 - Formulário de Cadastro
A imagem 15 demonstra a listagem de dados do protótipo salvos no banco de
dados, e recuperados para visualização.

Figura 18 - Tela de Consulta aos Dados Inseridos

Modelagem de Dados
Para a criação do banco de dados relacional, utilizando o PostgreSQL, foi feita a
seguinte modelagem:

23
 Figura 19 - Modelagem do Banco de Dados Relacional

Na tabela álbum, será realizado o relacionamento com as tabelas: gravadora,

artista e gênero através de uma chave estrangeira para cada um 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ário a instalação de um driver. O
link para o download do driver está disponível em
“http://docs.mongodb.org/ecosystem/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()”, onde
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:

24
 Figura 20- Iniciando uma conexão do PHP com o MongoDB

A seguir, selecionaremos o banco de dados do MongoDB que desejamos

manipular:

Figura 21- Definindo o Banco de Dados para manipulação

Para criar uma nova coleção, utilizamos o seguinte comando:

Figura 22- Criando nova coleção de documentos

Como podemos notar, o PHP tem classes prontas para manipular os dados com o
MongoDB, o que torna mais fácil a operações fundamentais: inserção,
atualização, deletar e consultar.
Como exemplo, vamos analisar o formulário do protótipo (figura 14). Quando o
botão “salvar” do formulário é pressionado, a aplicação executará um código em
PHP. A seguinte query será montada através de uma string utilizando código
PHP, para que os dados do formulário sejam inseridos na tabela do banco de
dados relacional:

Figura 23 - Query para PostgreSQL

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:

25
 Figura 24 - Exemplo de comando para execução da query

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 25 - Configuração para conexão PHP ao PostgreSQL

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.

26
 Figura 26 - Array parametro para inserção no MongoDB
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
musicas. 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 as
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, onde será
necessário criar uma string e executá-la com a classe do PostgreSQL.
Para realizar uma atualização em algum documento de uma coleção, utilizamos
em PHP o código a seguir:

Figura 27 - Update com MongoDB

O primeiro parâmetro para a função update é o equivalente a expressão where da
linguagem SQL, onde 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.

27
O comando para exclusão é idêntico ao de atualização:

Figura 28 - Remover registro com MongoDB

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 29 - Exemplos de consulta com MongoDB

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.

Resultados obtidos
Foi demonstrado uma óbvia diferença na sintaxe das operações nas quais a
finalidade era a mesma, para os casos de banco de dados relacional e o NoSQL,
Para que uma aplicação possa aproveitar ao máximo os recursos do NoSQL, é
necessário uma boa análise na estrutura de dados que será criada.
É necessário também a quebra de paradigmas criados no desenvolvimento
utilizando o banco de dados relacional, e sempre tratar coleções e documentos
diferente de tabelas e registros, para assim uma melhor utilização e entendimento
do NoSQL.
Porém, como foi analisado a partir do protótipo, o MongoDB possui praticamente
os mesmos recursos básicos de consultas que os bancos de dados relacionais
possuem.
Apesar dos bancos de dados NoSQL ainda serem menos utilizados do que os
bancos de dados relacionais, não foram encontrados muitas dificuldades nas
questões de documentação e tutoriais.
Como ponto fraco do MongoDB, foi apontado a questão do limite de 2 GB
estipulado para versões 32 bits. Além disso, as ferramentas gráficas para
administração dos dados ainda são precárias.

28
7. CONCLUSÕES
Como quase tudo na área de computação, não existe “melhor” ou “pior”, e sim o
que mais se enquadra no problema apresentado. A utilização ou não de NoSQL irá
depender da finalidade, e deve-se fazer uma análise do problema para decidir
então qual a melhor ferramenta para a solução.
Os bancos de dados NoSQL e seus gerenciadores, foram criados para a solução de
escalabilidade de sistema com grandes informações armazenadas.
Portanto, o NoSQL não veio para substituir os bancos de dados relacionais, e sim
“cobrir” os pontos fracos destes. Portanto, é possível utilizar na mesma aplicação
ambos os tipos de banco de dados.

29
 8. REFERÊNCIAS BIBLIOGRÁFICAS
Codd, E. F. (1970). Communications of the ACM, v. 13, n. 6, p. 377-387.
Cood, E. F. (1985). Is Your DBMS Really Relational?. Computer World.
Date C. J. (2003). Introdução A Sistemas de Banco de Dados. 8. Ed. Rio de
Janeiro: Elsevier.
Evans, E. (2009). NoSQL 2009 [on-line]. Disponível em “http://blog.sym-
link.com/2009/05/12/nosql_2009.html”.
Korth, H. F.; Silberschatz, A.; Sudarshan, S. (1999). Sistemas de Banco de
Dados. 3. Ed. - São Paulo: Makron Books.
MongoDB (2014). MongoDB: CRUD Operations [on-line]. Disponível em
“http://docs.mongodb.org/master/MongoDB-crud-guide.pdf”.
MongoDB (2014). The MongoDB 2.6 Manual [on-line]. Disponível em
“http://docs.mongodb.org/manual/”.
Nascimento, J. (2010). NoSQL – você realmente sabe do que estamos falando ?
[on-line]. Disponível em “http://imasters.com.br/artigo/17043/banco-de-
dados/NoSQL-voce-realmente-sabe-do-que-estamos-falando/”.
Neto, F. G. P. (2008). Banco de Dados Relacional - Exemplo [on-line].
Disponível em “http://e-reality-database.blogspot.com.br/2008/09/banco-de-
dados-relacional-exemplo.html”.
Neto, F. G. P. (2008). Banco de Dados de Rede - Exemplo [on-line]. Disponível
em “http://e-reality-database.blogspot.com.br/2008/09/banco-de-dados-de-rede-
exemplo.html”.
Neto, F. G. P. (2008). Banco de Dados Hierárquico - Exemplo [on-line].
Disponível em “http://erealityhome.wordpress.com/2008/09/08/banco-de-dados-
hierarquico-exemplo-2/”.
Strozzi, C. (2007). NoSQL Relational Database Management System: Home Page
[on-line]. Disponível em “http://www.strozzi.it/cgi-
bin/CSA/tw7/I/en_US/nosql/Home%20Page”.

30

View publication stats