Embed Size (px)
Citation preview
IntroduçãoHoje em dia, fala-se muito sobre os bancos de dados NoSQL. Porém, poucos ainda conhecem esse conceito, que não é novo.
Neste curso, explicarei o que são esses bancos de dados tão falados ultimamente, onde usar e por que usá-los. O foco será em um banco de dados largamente utilizado, que é o MongoDB, e demonstrarei exemplos de sua utilização real com o PHP, outra linguagem para Web largamente utilizada.
NOSQLO que é?
Por que usar?
Onde usar?
Tipos de armazenamento
Cases reais
Por que usar?O termo NoSQL foi utilizado pela primeira vez em 1998 como nome de um banco de dados relacional de código aberto que não possuía um interface SQL. Seu autor, Carlo Strozzi, alega que o movimento NoSQL "é completamente distinto do modelo relacional e portanto
deveria ser mais apropriadamente chamado "NoREL" ou algo que produzisse o mesmo efeito".
Porém, o termo só voltou a ser assunto em 2009 por um funcionário do Rackspace, Eric Evans, quando Johan Oskarsson da Last.fm queria organizar um evento para discutir bancos de dados open source distribuídos.
NoSQL são diferentes sistemas de armazenamento que vieram para suprir necessidades nas quais os bancos de dados tradicionais (relacionais) são ineficazes. Muitas dessas bases apresentam características interessantes, como: alta performance, escalabilidade, replicação, suporte a dados estruturados, grafos e sub-colunas.
O NoSQL surgiu da necessidade de uma performance superior e de alta escalabilidade. Os atuais bancos de dados relacionais são muito restritos a isso, sendo necessária a distribuição vertical de servidores, ou seja, quanto mais dados, de mais memória e de mais disco um servidor precisa.
O NoSQL tem uma grande facilidade na distribuição horizontal, ou seja, mais dados, mais servidores, não necessariamente de alta performance. Um grande utilizador desse conceito é o Google, que usa computadores de pequeno e médio porte para a distribuição dos dados. Essa forma de utilização é muito mais eficiente e econômica. Além disso, os bancos de dados NoSQL são muito tolerantes a erros.
No caso dos bancos NoSQL, toda a informação necessária estará agrupada no mesmo registro, ou seja, em vez de você ter o relacionamento entre várias tabelas para formar uma informação, ela estará em sua totalidade no mesmo registro.
Onde usar?Atualmente, temos vários bancos NoSQL que podem resolver diversos problemas. De qualquer forma, eles não são a chave para TODOS os problemas. Ainda existem cenários em que os bancos relacionais são mais indicados, visto que eles possuem propriedades ACID. Logo, são melhores em cenários em que os dados são muitíssimo importantes e não pode haver nenhuma quebra de referência. Ou seja, não indicaria, ainda, algum banco NoSQL para sistemas de transações financeiras, por exemplo.
Mas se o seu sistema é alguma rede social ou algum site que necessite de alta disponibilidade ou escalabilidade, com certeza lhe indicaria um banco NoSQL.
Entretanto, não precisamos mudar todo o sistema para algum banco NoSQL. Podemos utilizar um banco NoSQL e um relacional em conjunto. Como muitos já fazem, mas nem percebem. Por exemplo: um sistema que utiliza cache com certeza está usando um banco NoSQL no cache, como o mais conhecido Memcached. A API Storage do HTML5 também
utiliza um sistema de banco NoSQL do tipo chave-valor.
Tipo de armazenamentoExistem diversos tipos de armazenamento, no qual cada um trata os dados de uma forma diferente e que pode ser mais específico para o objetivo desejado.
Os tipo de armazenamento são: Wide Column Store/Column Families, Document Store, Key Value/Tuple Store, Eventually Consistent Key Value Store, Graph Databases, Object Databases, Grid Database Solutions, XML Databases. Lista retirada de http://nosql-database.org/
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 bancos de dados são o que tem a maior escalabilidade:
• Berkeley DB
• Tokyo Cabinet
• Kyoto Cabinet
• Project Voldermort
• MemcacheDB
• SimpleBD
• Redis
• Riak
Wide Columns Store
Fortemente inspirados pelo BigTable do Google, suportam várias linhas e colunas, e também permitem subcolunas. Além do BigTable do Google, outros que usam essa tecnologia são:
• HBase(Apache)
• HiperTable
• Cassandra(Apache)
Document Store
Baseados em documentos XML ou JSON, podem ser localizado pelo seu id único ou por qualquer registro que tenham no documento:
• CouchDB(Apache)
• MongoDB
• RavenDB
Graph Store
Com uma complexibilidade 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 destes objetos:
• Neo4J
• InfoGrid
• HyperGraphDB
Column Oriented Store
Esses são bancos de dados relacionais que têm características do NoSQL. A principal diferença deles é que os dados são armazenados em colunas, ajudando na escalabilidade:
• Vertica
• MonetDB
• LucidDB
• Infobright
• Ingres/Vectorwise
Na imagem abaixo, podemos ver um gráfico demonstrando a diferença entre o tamanho da base de dados e a complexidade dos seus dados. Assim, podemos perceber que os bancos do tipo chave-valor conseguem aguentar
mais dados, sendo que seus dados são mais simples, enquanto que os bancos do tipo grafo aguentam menos dados, e seus dados são mais complexos.
Cases reaisUm case real interessante é o da Netflix que utiliza 3 bancos NoSQL: SimpleDB, HBase e Cassandra.
O SimpleDB é uma implementação NoSQL da Amazon, e por isso foi escolhido, já que a
empresa utiliza o serviço AWS da Amazon. Ele escreve réplicas automáticas nas zonas disponíveis dentro de uma região. É altamente durável e também possui características, além de uma interface de chave-valor simples, como: vários atributos chave de linha, operações em lote, as leituras consistentes etc.O HBase é profundamente ligado ao Hadoop e pode escrever consultas em tempo real,
apesar de sacrificar um pouco a disponibilidade pela consistência dos dados.Cassandra foi a escolhida pela escalabilidade e pelo poder de replicar dados
assincronamente através de múltiplas regiões geográficas. Pode escalar dinamicamente adicionando mais servidores sem a necessidade de re-shard ou reiniciar.
Como se pode ver, cada banco vem para suprir alguma necessidade específica.
Esse foi um exemplo de como uma empresa pode utilizar vários bancos NoSQL para tratar de assuntos específicos. Porém, podemos usar facilmente apenas um para resolver nossos problemas.
O MongoDB, que será nosso banco de estudo, é usado pelas seguintes empresas em produção:
• Craigslist
• Shutterfly
• foursquare
• bit.ly
• SourceForge
• Disney
• MTV Networks
• GitHub
• Justin.tv
• CollegeHumor
• SugarCRM
• GrooveShark
• CartolaFC
Podemos ver mais empresas utilizando-o emhttp://www.mongodb.org/display/DOCS/Production+Deployments
MongoDB - IntroduçãoO MongoDB é um dos bancos NoSQL mais utilizados, pela sua facilidade de instalação, sua documentação e os diversos drivers para inúmeras linguagens de programação. Ele é um banco de dados orientado a documentos, escalável, livre de esquema, de alto desempenho e código aberto escrito em C++.
Algumas funcionalidades interessantes do MongoDB são:
• orientação a documentos(JSON/BSON)
• suporte a index
• replicação e alta disponibilidade
• auto-sharding
• map/reduce GridFS
• suporte comercial da 10gen.
Suas queries são simples e ricas. E seu map/reduce é bem flexível.
Quando utilizamos, vemos a grande diferença de velocidade entre o MongoDb e os outros bancos relacionais. Isso acontece principalmente por ele guardar os dados na memória RAM, persistindo-o no disco rígido também. Por isso, é altamente aconselhável sempre usar um segundo nó de réplica para, caso o servidor desligue, você não perder seus dados.
Para a maioria dos desenvolvedores que vem do mundo relacional, o MongoDB parecerá estranho, mas com o tempo é possível notar como ele é mais simples que a grande maioria dos SGBDs. A grande diferença, que para mim realmente é uma vantagem, é não possuir schema e não tentar representar um mundo n-dimensional com apenas 2
dimensões: coluna e linha.
No MongoDB, o conjunto de dados não se chama tabelas, mas sim coleção. Essa coleção possui uma estrutura de JSON, como no seguinte exemplo:
usuario{ nome: "Jean", apelido: "Suissa", idade: 26, telefone:{celular: 99998888, residencial:44445555}}
Como podemos ver nesse exemplo, além de possuir os campos nome, apelido e idade, o campo celular é uma lista de valores. Nossos documentos JSON podem conter outros documentos JSON dentro, e assim por diante. Você irá controlar tudo isso via programação.
Isso se diferencia bastante do modelo relacional, no qual todos os registros necessariamente precisam ter os mesmos campos, mesmo que sejam NULOS. Já no MongoDB você apenas acrescentará campos nos registros que realmente precisam. E, como havia dito anteriormente, o programador tem que ter muito mais cuidado com esse tipo de coisa para depois não se perder em suas estruturas.
Porém, não pense que esse modelo NOSQL serve para todos os casos. Os casos em que ele serve perfeitamente são: sistemas de logs, sistemas que não necessitam de controle de transação, que necessitam de alta escalabilidade e que não possuem dados críticos.
Uma dica que posso dar sobre como escolher o MongoDB para um projeto é pensar se o seu sistema terá muito mais leituras do que escritas concorrentes. Por exemplo: em um e-commerce, não haverá quase nenhum cliente escrevendo em cima de algum produto, porém haverá muitos clientes lendo esses registros. Esse é um caso clássico para se utilizar o MongoDb. Outro aspecto que pode modificar sua modelagem no MongoDB é pensar como suas informações serão lidas pela sua aplicação; nesse caso, você modelará seu banco pensando em agrupar suas informações para que sejam buscadas apenas uma vez e que o retorno dessas informações seja suficiente para a maioria das atividades executadas na aplicação.
Instalação1. 3.1.1 - Windows2. 3.1.2 - Linux3. 3.1.3 - MacOS
WindowsFaça o download para o Windows em http://www.mongodb.org/display/DOCS/Quickstart+Windows
Dezip o conteúdo do zip baixado em alguma pasta. Ex.: C:\mongo
Crie 2 pastas no seu C:\, pois o MongoDB utiliza como padrão essas 2 pastas.
C:\> mkdir \dataC:\> mkdir \data\db
Caso você queira utilizar pastas diferentes, use o atributo --dbpath quando iniciar o serviço do Mongo no seu console.
Para você iniciar o seu Mongo, vá até o console e digite:
• cd mongo\bin
• mongod
Após iniciado o serviço, você pode abrir outro console e ir na mesma pasta bin e rodar:
• mongo
Com isso, você estará rodando o cliente do MongoDB e já poderá testá-lo com seus comandos.
Agora baixe a extensão do Mongo para PHP em https://github.com/mongodb/mongo-php-driver/downloads
Baixe a versão correta para seu Windows e coloque a dll na pasta das suas extensões de PHP. Após isso, abra o seu php.ini e adicione a seguinte linha:
• extension=php_mongo.dll
LinuxPara instalar "automagicamente" o MongoDB, basta instalá-lo via apt-get, mas antes precisamos atualizá-lo:
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
Crie um arquivo /etc/apt/sources.list.d/10gen.list e adicione essa linha:
deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen
Agora só atualizamos:
sudo apt-get update
Para instalar seguimos a velha fórmula:
• $ sudo apt-get install mongodb-10gen
Agora instalaremos a extensão do Mongo para o PHP.
• $ sudo pecl install mongo
Crie as 2 pastas padrão que o Mongo utiliza com os seguintes comandos:
$ sudo mkdir -p /data/db/$ sudo chown `id -u` /data/db (caso não consiga. pode usar o chmod 777 -Rf na pasta /data, mas não é aconselhável)
• $ sudo pico /etc/php5/apache2/php.ini
• extension=mongo.so
Adicione a seguinte linha ao seu php.ini:
Reinicie seu Apache e confira se a extensão está rodando.
• $ sudo /etc/init.d/apache2 restart
Para conferir se a extensão está rodando, crie um arquivo php com o seguinte conteúdo:
<?phpphpinfo();?>
Procure por mongo e veja se ele está devidamente instalado.
Caso não consiga instalar via apt-get, pode baixar diretamente do site em:http://www.mongodb.org/downloads
Após a extração dos arquivos em uma pasta qualquer, você deve prestar atenção: quando você chama o binário mongo ou mongod, terá que fazer com a url completa da pasta.
Para você rodar o serviço do Mongo, basta rodar o seguinte comando:
• mongod
Em um outro terminal, você irá rodar o cliente do Mongo com o seguinte comando:
• mongo
MacOSPara instalar "automagicamente" o MongoDB, basta instalá-lo via apt-get:
$ brew update$ brew install mongodb
Ou se você usa ports:
• $ sudo port install mongodb
Agora, instalaremos a extensão do Mongo para o PHP.
• $ sudo pecl install mongo
Crie as 2 pastas padrão que o Mongo utiliza com os seguintes comandos:
$ sudo mkdir -p /data/db/$ sudo chown `id -u` /data/db (caso não consiga, pode usar o chmod 777 -Rf na pasta /data, mas não é aconselhável)
$ sudo pico /etc/php5/apache2/php.ini (ou onde seu php.ini estiver)
Adicione a seguinte linha ao seu php.ini:
• extension=mongo.so
Reinicie seu Apache e confira se a extensão está rodando.
• $ sudo /etc/init.d/apache2 restart (ou restart via MAMP)
Para conferir se a extensão está rodando, crie um arquivo php com o seguinte conteúdo:
<?phpphpinfo();?>
Procure por mongo e veja se ele está devidamente instalado.
Caso não consiga instalar via port ou brew, pode baixar diretamente do site em:http://www.mongodb.org/downloads
Após a extração dos arquivos em uma pasta qualquer, você deve prestar atenção: quando você chama o binário mongo ou mongod, terá que fazer com a url completa da pasta.
Para você rodar o serviço do Mongo, basta rodar o seguinte comando:
• mongod
Em um outro terminal, você irá rodar o cliente do Mongo com o seguinte comando:
• mongo
Comandos1. 3.2.1 - Coleção2. 3.2.2 - Inserção3. 3.2.3 - Consulta4. 3.2.4 - Alteração5. 3.2.5 - Exclusão6. 3.2.6 - Mapeamento SQL para MongoDB
ColeçãoAntes de criarmos uma coleção, precisamos criar uma Database e, para isso, usaremos o seguinte comando:
use nome_database
Caso a Database já exista, o Mongo apenas a setará como default. Para listarmos as databases criadas, usamos o seguinte comando:
• show dbs
Para criarmos uma coleção, precisamos apenas usá-la:
• db.nome_colecao.insert({a:1})
Sempre usaremos, para cada comando, o início db, que será o atalho para a database que escolhemos inicialmente com o comando use. A coleção só existirá após algum dado ser inserido nela.
Para listarmos as coleções, usamos o seguinte comando:
• show collections
Para deletarmos a coleção, usamos:
• db.nome_colecao.drop()
Se quisermos apenas limpar a coleção sem apagá-la, usamos:
• db.nome_colecao.remove()
Caso queiramos criar uma collection sem utilizá-la inicialmente, podemos usar o seguinte comando:
• db.createCollection("minha_collection")
InserçãoPara inserirmos algum dado, sempre utilizamos um documento no formato JSON. Usaremos o comando insert() da seguinte forma:
db.professores.insert({nome: ?Jean?, idade:26, disciplinas:[?PHP?, ?
NOSQL?], sexo: ?m?, created : new Date('12/21/2012')})
Ou também podemos criar um JSON com os dados e passá-lo como parâmetro para a função, como no exemplo a seguir:
json = {nome: ?Jean?, idade:26, disciplinas:[?PHP?, ?NOSQL?], sexo: ?m?,
created : new Date('12/21/2012')}
db.professores.insert(json)
ConsultaPara fazermos consultas no MongoDB, utilizaremos 2 funções:
• find()
• findOne()
Possuímos a seguinte sintaxe para fazermos consultas:db.colecao.find({clausulas, campos})
E, para usarmos como WHERE, são necessários alguns operadores especiais que listo na próxima página. Caso seja necessária uma consulta por string mais complexa, podemos usar REGEX.
db.professores.find( { nome : /J*/i } );<br />db.professores.find( {
name : { $regex : 'J*'} } );
Agora veremos um paralelo entre algumas funções de seleção da SQL e sua alternativa para o Mongo:
select count(*) from professores<br />db.professores.count()
select count(*) from professores where idade > 30<br /
>db.professores.count({idade:{$gt: 30}})
select nome from professores where idade < 18<br /
>db.professores.find({idade: {$lt: 18}}))
select nome, idade from professores<br />db.professores.find(null,
{nome:1, idade:1} )
select nome, idade from professores where idade >= 18<br /
>db.professores.find({idade:{$gte: 18}}, {nome:1, idade:1} )
select * from professores order by nome ASC <br /
>db.professores.find().sort({nome:1})
select * from professores order by idade DESC <br /
>db.professores.find().sort({idade:-1})
select * from professores order by nome ASC limit 0,2 <br /
>db.professores.find().sort({nome:1}).limit(2)
select * from professores limit 2 offset 10<br /
>db.professores.find().limit(2).skip(10)
Entretanto, qualquer seleção com find() irá retornar um cursor do MongoDB no qual você precisará iterar para retirar suas informações, enquanto que utilizando o findOne() você retornará apenas 1 registro.
select nome, idade from professores LIMIT 0,1<br /
>db.professores.findOne(null, {nome:1, idade:1} )
Operadores CondicionaisNo MongoDB, utilizamos operadores especiais para criar nossos critérios de busca. Abaixo, a lista desses operadores:
• < ou $lt
• <= ou $lte
• > ou $gt
• >= ou $gte
• $all - retorna o objeto no qual todos os valores foram encontrados
• $exists - retorna o objeto caso uma chave exista
• $mod - retorna o objeto quando o módulo de um valor foi encontrado
• $ne- retorna o objeto no qual o valor não foi encontrado
• $in- retorna o objeto se o valor foi encontrado
• $nin- retorna o objeto se nenhum dos valores foi encontrado
• $nor- retorna o objeto caso a cláusula negação do OU for verdadeira
• $or- retorna o objeto caso a cláusula OU for verdadeira
• $and- retorna o objeto caso a cláusula E for verdadeira
• $size
• $type - retorna o objeto caso a chave seja do tipo especificado para conferir a lista dos tipos e seus valores. Acesse a lsta dos tipos e seus valores inserir bloco
OrdenaçãoPara ordenarmos uma consulta no MongoDB, precisamos apenas utilizar a função sort(), como no exemplo a seguir:
db.professores.find({}).sort({email: 1});
Utilizamos o valor 1 para ordenação ASCENDENTE e -1 para ordenação DESCENDENTE.
Skip e LimitPara pularmos o início do retorno dos nossos registros, usamos a função skip() e, para limitarmos a quantidade de registros retornados, utilizamos a função limit(), como demonstrado abaixo:
db.professores.find().skip(20).limit(10);
CursoresQualquer busca feita com o find() irá retornar um cursor e, para retirarmos os valores dele, precisamos iterar nele como no exemplo abaixo:
var cur = db.professores.find();
cur.forEach( function(x) { print(tojson(x))});
AlteraçãoPara realizarmos alterações, podemos fazer uma consulta que irá retornar um JSON. Podemos manipulá-lo e mandar o Mongo para salvar o objeto com a modificação. Podemos fazer isso da seguinte forma:
Para realizarmos uma alteração no MongoDB, podemos utilizar 2 funções:
• save()
• update()
A diferença entre o save() e o update() é que a função save() irá criar o registro caso ele não encontre nenhum que bata com o seu critério de busca. Porém, isso também pode ser feito com o parâmetro upsert na função update().
A sintaxe para a função update() é a seguinte:db.collection.update( criterio, obj, upsert, multi )
• criterio - query que irá selecionar o registro para alterar
• objNew - objeto modificado ou operadores de alteração
• upsert - caso o registro não exista, ele será inserido
• multi - caso encontre mais de um registro pelo criterio, ele atualiza todos esses registros
Caso você não passe o parâmetro multi, ele só atualiza um único registro.
Exemplo da diferença entre o update() e o save():
db.minhaCollection.save(x);
db.minhaCollection.update( { _id: x._id }, x, /*upsert*/ true )
A forma mais simples de se alterar um registro é pesquisando-o com findOne, editando-o e, após isso, salvando. Caso precise apenas salvar, simplesmente aconselho o uso da função save(), como a seguir:
professor = db.professores.findOne( { nome : "Jean" } );<br /
>professor.idade = 28;<br />db.professores.save(professor);
Mas também podemos alterar diretamente com o update:professor = db.professores.findOne( { nome : "Jean" } );<br /
>professor.idade = 27;<br />db.professores.update({ nome : "Jean" },
{$set: {idade: 28} });
Fora isso, podemos usar diversos operadores na query, exemplo:db.professores.update( { nome:"Jean" }, { $inc: { visitas: 1 }, $set: {
idade: 28 } } );
Operadores de ModificaçãoOs operadores de modificação servem para que você possa alterar valores nos registros diretamente na query do MongoDB. Como vimos anteriormente, para atualizar minha idade de 27 para 28 anos, usamos o operador $set.
$inc{ $inc : { campo : valor } }
Incrementa um valor no campo; caso o campo não exista, ele irá criar o campo e setar o valor. Para decrementar, basta passar um valor negativo.
$set{ $set : { campo : valor } }
Seta o valor do campo.
$unset
{ $unset : { campo : 1} }
Deleta o campo.
$push{ $push : { campo : valor } }
Adiciona um valor ao campo se o campo for um array existente. Caso contrário, transforma o campo em um array com o valor como índice. Porém, se o campo existe e não for um array, irá retornar um erro.
Arrays múltiplos podem ser alterados em uma única operação separando os pares de campo : valor por vírgula.
{ $push : { campo1 : valor, campo2 : valor2 } }
$pushAll{ $pushAll : { campo : valor_array } }
Adiciona cada valor dentro de valor_array para o campo se o campo for um array existente. Caso contrário, seta o campo com o valor_array. Se o campo estiver presente mas não for um array, irá retornar um erro.
$addToSet e $each{ $addToSet : { campo : valor } }
Adiciona um valor para um array somente se o valor ainda não estiver no array, caso o campo seja um array existente. Caso contrário, seta o campo para o array se o campo não existir. Se o campo estiver presente e não for array, irá retornar um erro.
Para adicionar uma lista de vários valores, use o qualificador $each:{ $addToSet : { a : { $each : [ 3 , 5 , 6 ] } } }
$pop{ $pop : { campo : 1 } }
Remove o último elemento do array campo.
$pull{ $pull : { campo : _valor } }
Remove todas as ocorrências de _valor no campo se o campo for um array. Se o campo estiver presente mas não for array, irá retornar um erro.
Para acertar um valor exato, você também pode usar expressões como essas:{ $pull : { campo : {<criterio>} } } //remove elementos do array que
batam com o seu critério
{ $pull : { campo : {campo2: valor} } } //remove os elementos do array
com campo2 possuindo o valor
{ $pull : { campo : {$gt: 3} } } //remove elementos do array que forem
maior que 3
$pullAll{ $pullAll : { campo : valor_array } }
Remove todas as ocorrências de cada valor no valor_array do campo se o campo for um array. Se o campo existir mas não for um array, irá retornar um erro.
$rename{ $rename : { nome_campo_antigo : nome_campo_novo } }
Renomeia o nome_campo_antigo para nome_campo_novo.
ExclusãoPara excluir dados, utilizamos a mesma lógica, porém com a função remove().
db.professores.remove(); // exclui tudo<br /
>db.professores.remove({nome: "Jean"}); // exclui todos os professores
com nome = Jean
O jeito mais eficiente de remover um documento é utilizando seu ObjectID, exemplo:
professor = db.professores.findOne({nome: "Jean"})
db.professores.remove({_id: professor._id});
Mapeamento SQL para MongoDB
Vamos ver alguns exemplos de SQL e sua tradução para o PHP usando MongoDB:
INSERT INTO USERS VALUES(1,1)$db->users->insert(array("a" => 1, "b" => 1));
SELECT a,b FROM users$db->users->find(array(), array("a" => 1, "b" => 1));
SELECT * FROM users WHERE age=33$db->users->find(array("age" => 33));
SELECT a,b FROM users WHERE age=33$db->users->find(array("age" => 33), array("a" => 1, "b" => 1));
SELECT a,b FROM users WHERE age=33$db->users->find(array("age" => 33), array("a" => 1, "b" => 1));
SELECT a,b FROM users WHERE age=33 ORDER BY name $db->users->find(array("age" => 33), array("a" => 1, "b" => 1))->sort(array("name" => 1));
SELECT * FROM users WHERE age>33 $db->users->find(array("age" => array('$gt' => 33)));
SELECT * FROM users WHERE age<33 <br />$db->users->find(array("age" => array('$lt' => 33)));
SELECT * FROM users WHERE name LIKE "%Joe%"$db->users->find(array("name" => new MongoRegex("/Joe/")));
SELECT * FROM users WHERE name LIKE "Joe%" $db->users->find(array("name" => new MongoRegex("/^Joe/")));
SELECT * FROM users WHERE age>33 AND age<=40$db->users->find(array("age" => array('$gt' => 33, '$lte' => 40)));
SELECT * FROM users ORDER BY name DESC$db->users->find()->sort(array("name" => -1));
CREATE INDEX myindexname ON users(name)$db->users->ensureIndex(array("name" => 1));
CREATE INDEX myindexname ON users(name,ts DESC)$db->users->ensureIndex(array("name" => 1, "ts" => -1));
SELECT * FROM users WHERE a=1 and b='q'$db->users->find(array("a" => 1, "b" => "q"));
SELECT * FROM users LIMIT 10 SKIP 20$db->users->find()->limit(10)->skip(20);
SELECT * FROM users WHERE a=1 or b=2$db->users->find(array('$or' => array(array("a" => 1), array("b" => 2))));
SELECT * FROM users LIMIT 1$db->users->find()->limit(1);
EXPLAIN SELECT * FROM users WHERE z=3$db->users->find(array("z" => 3))->explain()
SELECT DISTINCT last_name FROM users$db->command(array("distinct" => "users", "key" => "last_name"));
SELECT COUNT(*) FROM users$db->users->count();
SELECT COUNT(*) FROM users where AGE > 30$db->users->find(array("age" => array('$gt' => 30)))->count();
SELECT COUNT(AGE) from users $db->users->find(array("age" => array('$exists' => true)))->count();
UPDATE users SET a=1 WHERE b='q'$db->users->update(array("b" => "q"), array('$set' => array("a" => 1)));
UPDATE users SET a=a+2 WHERE b='q'$db->users->update(array("b" => "q"), array('$inc => array("a" => 2)));
DELETE FROM users WHERE z="abc"$db->users->remove(array("z" => "abc"));
ShardingO MongoDB suporta uma arquitetura automatizada sharding/partição, permitindo escalar horizontalmente em vários nós. Para aplicações que superam os recursos de um servidor de banco de dados único, o MongoDB pode converter para um cluster sharded, gerenciando automaticamente o failover e o balanceamento de nós, com poucas mudanças ou não para o código do aplicativo original.
Sharding é o particionamento de dados entre vários computadores de uma forma de preservação da ordem. Para dar um exemplo, vamos imaginar sharding como uma coleção de usuários pelo seu estado de residência. Em uma visão simplista, se designar três máquinas como servidores de nossos cacos, os usuários podem ser divididos por máquina da seguinte forma:
Dividindo a quantidade de estados existentes pelo número de shards existentes. Pensando na quantidade de dados existentes por estado para fazer um balanceamento correto.
Nosso aplicativo se conectará ao cluster sharded através de um processo Mongos, que encaminha as operações para o(s) shard(s) apropriado(s). Dessa forma, o aglomerado MongoDB sharded se parecerá como um único servidor lógico para a nossa aplicação. Desde que nossos documentos estejam organizados em uma forma de preservação da ordem, todas as operações que especificam o estado de residência serão encaminhadas apenas para os nós que contêm esse estado.
Como o nosso foco é trabalhar com PHP, não me aprofundarei nesta sessão, pois o assunto é muito extenso.
ConfiguraçãoComponentes Sharding
Primeiro configuramos os fragmentos individuais (mongod's), depois os servidores de configuração e os processos Mongos.
Servidores Shard
Um servidor de shard consiste em um processo de mongod ou em um conjunto de réplicas de processos mongod. Para a produção, vamos usar um conjunto de réplicas para cada fragmento de dados para segurança e failover automático. Para começar com um teste simples, podemos executar um único processo mongod por shard, como uma configuração de teste não exige failover automatizado.
Servidores de configuração
Vamos executar um mongod --configsvr para cada servidor de configuração. Se você está apenas testando, pode usar apenas um servidor de configuração. Para a produção, usar três pelo menos.
A replicação dos dados para cada configuração do servidor é gerenciada pelo roteador (mongos), pois eles têm um protocolo de replicação síncrona otimizado para três máquinas. Não execute qualquer um dos servidores de configuração com - replSet; pois a replicação entre eles é automática.
Mongos Router
Execute o processo mongos nos servidores de sua escolha. Especifique o parâmetro - configdb para indicar a localização da base de dados de configuração(s).
Nota: não use os nomes de DNS, endereços, para o ip. Caso você use, quando mover os servidores de configuração mais tarde, será mais difícil.
Note que cada Mongos vai ler o primeiro servidor de configuração na lista fornecida. Se você estiver executando servidores de configuração em mais de um centro de dados, você deve colocar os servidores mais próximos de configuração no início da lista.
ExemploServidores Shard
Primeiramente precisamos criar os serviços de sharding. Esse exemplo é
apenas didático e será rodado em apenas um servidor.
mkdir /data/db/a /data/db/b
mongod --shardsvr --dbpath /data/db/a --port 10000 > /tmp/sharda.log &
cat /tmp/sharda.log
mongod --shardsvr --dbpath /data/db/b --port 10001 > /tmp/shardb.log &
cat /tmp/shardb.log
Obs.: O cat serve apenas para verificarmos se o serviço subiu realmente
e o & serve para rodar em background.
Servidores de Configuraçãomkdir /data/db/config
mongod --configsvr --dbpath /data/db/config --port 20000 > /tmp/
configdb.log &
cat /tmp/configdb.log
Mongos Routermongos --configdb localhost:20000 > /tmp/mongos.log &
cat /tmp/mongos.log
Precisamos dizer qual é a nossa database, collection e shard key.
db.runCommand( { enablesharding : "test" } )
{"ok" : 1}
db.runCommand( { shardcollection : "test.people", key : {name : 1} } )
{ "collectionsharded" : "test.people", "ok" : 1 }
GridFSGridFS é uma especificação para armazenar grandes arquivos, e ele provê um mecanismo transparente para a divisão dos arquivos em vários documentos. Então, podemos manipular os arquivos como se fossem documentos, ou seja, podemos pesquisar por seus metadados facilmente.
Devemos usar o GridFS para arquivos que mudam constantemente; assim, só precisamos atualizá-lo em um nó que os outros serão replicados.
Os arquivos são limitados a 16 MB, sendo normalmente divididos em pequenos pacotes chamados chunks de 256 K. Cada chunk é dividido em um documento separado dos outros na coleção de chunks. Já seus metadados são salvos na coleção de arquivos.
O interessante de o GridFS quebrar o arquivo em pequenos pedaços é que ele não precisa jogar todo o arquivo na memória RAM como o MongoDB faz com os dados. Em vez disso, ele faz o streaming dos chunks para o nosso usuário. Isso significa que teoricamente você não necessita de mais de 4 MB para trabalhar com os arquivos, independentemente do tamanho deles.
GridFS utiliza-se de 2 coleções para o armazenamento dos arquivos:
• files - contém os metadados
• chunks - contém os arquivos binários e os dados adicionais
files
O documento da coleção files necessita dos seguintes dados:{<br /> "_id" : <unspecified>, // ID único para este
arquivo<br /> "length" : data_number, // tamanho do
arquivo em bytes<br /> "chunkSize" : data_number, //
tamanho de cada chunks. Padrão é 256k<br /> "uploadDate" : data_date,
// data de quando foi armazenado<br /> "md5" : data_string
// md5 do arquivo<br />}
chunks
A estrutura dos documentos dos chunks segue o seguinte padrão:{<br /> "_id" : <unspecified>, // object id of the chunk in
the _chunks collection<br /> "files_id" : <unspecified>, // _id of
the corresponding files collection entry<br /> "n" : chunk_number,
// chunks are numbered in order, starting with 0<br /> "data" :
data_binary, // the chunk's payload as a BSON binary type<br /
>}
Agora vamos ver isso na prática! Abra seu console em uma pasta na qual você possua algum arquivo que queira guardar no GridFS para teste e digite no console:
./mongofiles -d myfiles put minha_musica.mp3
connected to: 127.0.0.1
added file: {
_id: ObjectId('4ce9ddcb45d74ecaa7f5a029'),
filename: "minha_musica.mp3",
chunkSize: 262144,
uploadDate: new Date(1290395084166),
md5: "7872291d4e67ae8b8bf7aea489ab52c1",
length: 1419631 }
done!
Nesse caso, nós usamos o comando PUT para enviar o arquivo minha_musica.mp3 para a database myfiles na coleção fs.files. Então, vamos listar nossos arquivos agora:
$ ./mongofiles -d myfiles list
connected to: 127.0.0.1
minha_musica.mp3 1419631
Para pesquisarmos nosso arquivo via console do Mongo, faremos o seguinte:
> use myfiles;
> db.fs.files.find({});
{
"_id" : ObjectId("4ce9ddcb45d74ecaa7f5a029"),
"filename" : "03-smbd-menu-screen.mp3",
"chunkSize" : 262144,
"uploadDate" : "Mon Nov 22 2010 03:04:44 GMT+0000 (UTC)",
"md5" : "7872291d4e67ae8b8bf7aea489ab52c1",
"length" : 1419631
}
Exemplo em PHPPara usarmos o GridFS no PHP, utilizamos a classe MongoGridFS
Neste exemplo, usaremos MongoGridFS::storeFile, mas também podemos usar o MongoGridFS::put como havíamos visto anteriormente em linha de comando.
<?php
// Conecta no Mongo e seta DB e Collection
$mongo = new Mongo();
$db = $mongo->myfiles;
// GridFS
$gridFS = $db->getGridFS();
// Localização da pasta com os arquivos
$path = "/tmp/";
$filename = "minha_musica.mp3";
// Olhe os campos metadata e filename
$storedfile = $grid->storeFile($path . $filename,
array("metadata" => array("filename" => $filename),
"filename" => $filename));
// Retorna o ID do arquivo armazenado
echo $storedfile;
?>
Caso necessite armazenar uma string como arquivo, utilizamos a função storeBytes, como no exemplo abaixo:
$storedfile = $grid->storeBytes("Isso é um teste de STRING!",
array("metadata" => array("filename" => $filename),
"filename" => $filename));
Neste exemplo, vamos ver como recuperar uma imagem do banco e mostrá-la.
<?php
// Conecta no Mongo e seta DB e Collection
$mongo = new Mongo();
$db = $mongo->myfiles;
// GridFS
$gridFS = $db->getGridFS();
// Procura a imagem
$image = $gridFS->findOne("minha_foto.jpg");
// Mostra no navegador
header('Content-type: image/jpeg');
echo $image->getBytes();
?>
Agora nos falta apenas deletar o arquivo. Para isso, utilizamos a função remove como para os dados comuns.
<?php
// Conecta no Mongo e seta DB e Collection
$mongo = new Mongo();
$db = $mongo->myfiles;
// GridFS
$gridFS = $db->getGridFS();
// Procura e deleta o arquivo
$removeFile = $gridFS->remove(
array("_id" => new MongoId("4ceb167810f1d50a80e1c71c"))
);
?>
DBRefO DBRef é uma especificação mais formal para a criação de referências entre os documentos. Sua utilização é mais voltada para ligações entre documentos em que seus valores podem mudar.
Como não possuímos JOINs no MongoDB, podemos referenciar ligações entre collections no lado do cliente ou com consultas adicionais. No lado do servidor, podemos referenciar manualmente ou com o DBRef.
O DBRefs possui os seguintes campos:
• $ref: nome da collection referenciada.
• $id: valor do _id do documento referenciado.
• $db: opcional e contém o nome da database onde o documento está referenciado.
Um documento DBRef pode ser exemplificado assim:{ $ref : <value>, $id : <value>, $db : <value> }
new DBRef ( 'customers' , ObjectId("4ef4a61a90eec3e3c748263c") )
Porém, o DBRef pode causar maior lentidão nas buscas, pois ele irá fazer a buscas dos documentos atrelados viaDBRef e, caso o documento atrelado seja muito grande, poderá haver uma perda de performance grande. Para isso, utilizamos a referência manual, na qual passamos o vamos do ObjectID diretamente.
Vamos a um exemplo utilizando DBRef:
db.fruit.save ({"_id" : "1" , "name" : "apple"});
db.fruit.save ({"_id" : "2" , "name" : "grape"});
db.fruit.save ({"_id" : "3" , "name" : "orange"});
db.fruit.save ({"_id" : "4" , "name" : "pineapple"});
db.basket.save ({"_id" : "1", "items" : [
{"quantity" : 5 , item : {"$ref" : "fruit", "$id" : "1"}},
{"quantity" : 10, item : {"$ref" : "fruit", "$id" : "3"}}
]})
db.basket.find()
Como podemos ver, o valor do relacionamento está em nosso objeto, porém o objeto relacionado não está. Para resolver isso, nós precisamos utilizar a função fetch() no objeto que contém as referências, como no exemplo:
> b = db.basket.findOne()
{
"_id" : "1",
"items" : [
{
"quantity" : 5,
"item" : {
"$ref" : "fruit",
"$id" : "1"
}
},
{
"quantity" : 10,
"item" : {
"$ref" : "fruit",
"$id" : "3"
}
}
]
}
> b.items
[
{
"quantity" : 5,
"item" : {
"$ref" : "fruit",
"$id" : "1"
}
},
{
"quantity" : 10,
"item" : {
"$ref" : "fruit",
"$id" : "3"
}
}
]
> b.items[0]
{ "quantity" : 5, "item" : { "$ref" : "fruit", "$id" : "1" } }
> b.items[0].item.fetch()
{ "_id" : "1", "name" : "apple" }
Admin UIsSistemas para administração visual são uma mão na roda para qualquer banco de dados, como o largamente usado phpmyadmin para o Mysql. Não seria diferente para o MongoDB - existem diversos sistemas desses nas mais variadas linguagens. Uma boa listagem se encontra emhttp://www.mongodb.org/display/DOCS/Admin+UIs
Aqui listarei alguns em PHP, que é o nosso foco:
PhpMoAdmin - http://www.phpmoadmin.com/RockMongo - http://code.google.com/p/rock-php/wiki/rock_mongo
Frameworks que suportamVários frameworks e CMS de PHP já possuem um biblioteca para trabalhar com o MongoDB. Entre eles posso listar:
CakePHP:
• https://github.com/ichikaway/cakephp-mongodbCodeigniter:
• https://github.com/kyledye/MongoDB-CodeIgniter-DriverFatFree
• http://fatfree.sourceforge.net/page/data-mappersKohana
• https://github.com/Wouterrr/mangodbLithium
• http://lithify.me/docs/lithium/data/source/MongoDbSymfony 2 :
• http://code.google.com/p/mongodbloganalyzer/
• http://www.symfony-project.org/plugins/sfStoragePerformancePlugin
• https://github.com/brtriver/sfMongoSessionStorageYii
• http://canni.github.com/YiiMongoDbSuite/Zend Framework
• https://github.com/coen-hyde/Shanty-Mongo
• https://github.com/stunti/Stunti_Cache_Backend_Mongo
• http://framework.zend.com/wiki/display/ZFPROP/Zend_Nosql_Mongo+-+Valentin+GolevDrupal:
• http://drupal.org/project/mongodb
Tipos de DadosO MongoDB usa tipos de dados especiais além dos tipos básicos de JSON string, integer, boolean, double, array, null e objeto. Esses tipos incluem date, object id, binary data, regular expression e code. Cada driver implementa esses tipos em linguagem específica. Para conhecer maneiras melhores, consulte a documentação do seu driver.
Para verificar qual o tipo do dado no console, basta apesar usar a função typeof. Exemplo:
> x
{
"_id" : ObjectId("4dcd3ebc9278000000005158"),
"d" : ISODate("2011-05-13T14:22:46.777Z"),
"b" : BinData(0,""),
"c" : "suissa",
"n" : 27,
"e" : [ ],
"n2" : NumberLong(33)
}
> x.d instanceof Date
true
> x.b instanceof BinData
true
> typeof x
object
> typeof x.b
object
> typeof x.n
number
> typeof x.n
number
> typeof x.n2
object
> x.n2 instanceof NumberLong
true
> typeof x.cstring
HostsExistem alguns serviços onde você pode hospedar bancos MongoDB:
• MongoHQ - https://mongohq.com/
• HostedMongo - http://hostedmongo.com/
• MongoLab - https://mongolab.com/home/
• MongoGrid - http://nodegrid.com/resources/mongogrid/
Classe MongoDBEssa é a classe nativa do MongoDB para PHP. http://php.net/manual/en/class.mongodb.phpApós instanciá-la, você já poderá interagir com o MongoDB.
Em nome de databases, é possível usar um grande números de caracteres ASCII, porém eles não podem conter " ", "." ou ser uma string vazia. A palavra "system" também é reservada. Diferentemente das coleções, databases podem conter "$".
MongoDB {
/* Constants */
const int PROFILING_OFF = 0 ;
const int PROFILING_SLOW = 1 ;
const int PROFILING_ON = 2 ;
/* Fields */
public integer $w = 1 ;
public integer $wtimeout = 10000 ;
/* Methods */
public array authenticate ( string $username , string $password )
public array command ( array $command [, array $options = array() ]
)
public __construct ( Mongo $conn , string $name )
public MongoCollection createCollection ( string $name [, bool
$capped = FALSE [, int $size = 0 [, int $max = 0 ]]] )
public array createDBRef ( string $collection , mixed $a )
public array drop ( void )
public array dropCollection ( mixed $coll )
public array execute ( mixed $code [, array $args = array() ] )
public bool forceError ( void )
public MongoCollection __get ( string $name )
public array getDBRef ( array $ref )
public MongoGridFS getGridFS ([ string $prefix = "fs" ] )
public int getProfilingLevel ( void )
public bool getSlaveOkay ( void )
public array lastError ( void )
public array listCollections ( void )
public array prevError ( void )
public array repair ([ bool $preserve_cloned_files = FALSE [, bool
$backup_original_files = FALSE ]] )
public array resetError ( void )
public MongoCollection selectCollection ( string $name )
public int setProfilingLevel ( int $level )
public bool setSlaveOkay ([ bool $ok = true ] )
public string __toString ( void )
}
ConexãoCriar uma conexão entre o PHP e o Mongo é bem simples. Vamos usar o seguinte comando:
• $m = new Mongo();
Caso necessite se autenticar para se conectar, use
• $m = new Mongo("mongodb://${username}:${password}@localhost");
Após instanciarmos nossa classe Mongo, setamos qual database usaremos.
• $db = $m->escola;
CRUDAbaixo, veremos um código bem simples para fazermos um CRUD com PHP e MongoDB. Vamos usar um arquivo de configuração apenas para não repetir os dados da conexão.
<?php
//mongo_config.php
$conn = new Mongo();
$db = $conn->test;
$collection = $db->people;
?>
Create
Criamos nosso index.php com o nosso formulário para inserirmos os dados.
<?php
require_once('mongo_config.php');
?>
<form action="cria_usuarios.php" method="post">
<p>
<label for="name">Nome:</label>
<input type="text" name="nome">
</p>
<p>
<label for="age">Idade:</label>
<input type="text" name="idade">
</p>
<p>
<label for="likes">Likes:</label>
<input type="text" name="likes">
</p>
<p>
<input type="submit" value="Save">
</p>
</form>
Depois criamos o create_users.php, que será a página que receberá nosso POST do form.
<?php
require_once('mongo_config.php');
//create_users.php
function check_empty($ar){
$empty = 0;
if(is_array($ar)){
foreach($ar as $v){
if(empty($v)){
$empty = 1;
}
}
}
return $empty;
}
if(!empty($_POST)){
$people = $collection->find();
$people_count = $people->count();
$empty = check_empty($_POST);
if($empty != 1){
$id = $people_count + 1;
$name = $_POST['name'];
$age = $_POST['age'];
$likes = $_POST['likes'];
$person = array('id'=>$id, 'name'=>$name, 'age'=>$age, 'likes'=>$likes);
$collection->insert($person);
echo $name . ' is registered!';
}else{
echo 'Please fill out all the fields!';
}
}
?>
Read
Agora criamos outra página chamada listagem.php e colocamos o código abaixo:
<?php
require_once('mongo_config.php');
$people = $collection->find();
$people_count = $people->count();
echo $people_count . ' pessoas achadas<br/>';
if($people_count > 0){
?>
<table border="1">
<thead>
<tr>
<th>ID</th>
<th>Nome</th>
<th>Idade</th>
<th>Likes</th>
</tr>
</thead>
<tbody>
<?php foreach($people as $v){ ?>
<tr>
<td><a href="update_user.php?nome=<?php echo $v['nome']; ?
>"><?php echo $v['id']; ?></a></td>
<td><?php echo $v['nome']; ?></td>
<td><?php echo $v['idade']; ?></td>
<td><?php echo $v['likes']; ?></td>
</tr>
<?php } ?>
</tbody>
</table>
<?php } ?>
Update
Precisamos listar todos os usuários novamente, porém, desta vez, não vamos apenas mostrá-los em uma tabela, vamos dar um link para cada usuário, para que eles sejam levados para o form de atualização.
<a href="atualiza_usuario.php?name=<?php echo $v['name']; ?>">
Depois, criamos a página atualiza_usuario.php e colocamos o seguinte código:
<?php
require_once('mongo_config.php');
// Aqui recebemos o POST do FORM atualizando os dados
if(!empty($_POST)){
$empty = check_empty($_POST);
if($empty != 1){
$nome = $_POST['nome'];
$idade = $_POST['idade'];
$likes = $_POST['likes'];
$query = array('nome'=>$nome);
$person = $collection->findOne($query);
$person['idade'] = $idade;
$person['likes'] = $likes;
$collection->save($person);
echo 'Update Successful!';
}
}
// Aqui recebemos o nome da pessoa que estamos querendo atualizar
if(!empty($_GET['nome'])){
$nome = $_GET['nome'];
$query = array('nome'=>$nome);
$person = $collection->findOne($query);
$nome = $person['nome'];
$idade = $person['idade'];
$likes = $person['likes'];
?>
<form action="update_user.php" method="post">
<p>
<label for="name">Nome:</label>
<input type="text" name="nome" value="<?php echo $nome; ?>" readonly>
</p>
<p>
<label for="age">Idade:</label>
<input type="text" name="idade" value="<?php echo $idade; ?>">
</p>
<p>
<label for="likes">Likes:</label>
<input type="text" name="likes" value="<?php echo $likes; ?>">
</p>
<p>
<input type="submit" value="Update">
</p>
</form>
<?php } ?>
Delete
Agora o código para deletar vai ficar por sua conta. Lembre-se do findOne e do remove.
ExercícioDepois de termos um CRUD funcional com PHP, vamos fazer um pequeno exercício, transformando nosso exemplo anterior em um CRUD orientado a objetos. Nesse exercício, você precisará criar uma classe de Conexão com o MongoDB, uma classe de Pessoa com suas funções, uma página como Controller da ações e suas respectivas Views.
Podem entrar em contato comigo para tirar suas dúvidas e validar o exercício.
Sistema de TarefasNeste módulo, criaremos um sistema simples de tarefas para entendermos o conceito por trás do MongoDB. Não quis me focar muito na separação dos arquivos, e sim na funcionalidade. Creio que a partir dessa base você já estará apto para criar sistemas simples que se encaixem bem com o MongoDB.
