janeiro 27th, 2012 | by admin | bigtable, cassandra, couchdb, escalabilidade, hbase, hypertable, memcached, mongodb, mysql, neo4j, nosql, redis
jan
27
Pessoal achei um pdf interessante sobre NOSQL do Rick Cattell quem quiser dar uma olhada está aí o link: http://cattell.net/datastores/Datastores.pdf
janeiro 25th, 2012 | by tiago | mongodb
jan
25
Nesse post vou explicar como reparar o MongoDB no Ubuntu de forma fácil e rapida. Eu particularmente tive um problema com o mongo esses dias, onde sempre que eu tentava efetuar uma conexão com o mongo recebia o seguinte erro:
Error: couldn't connect to server 127.0.0.1} (anon):1137
Pesquisando um pouco na net, descobri que esse erro acontece devido algum desligamento incorreto efetuado anteriormente. Vamos ver agora como corrigir.
Por que o mongodb não inicia?
Infelizmente até o momento o mongodb não consegue se recuperar muito bem quando ele crasha o que nos força a ter que recuperá-lo na unha.
mongo no terminal). Você provavelmente recebeu o erro citado acima.sudo status mongodb, isso deverá retornar mongodb stop/waiting.mongodb start/running, process XXXX), porém se você der um sudo status mondodb novamente, verá que ele continua parado stop/waiting.************** old lock file: /var/lib/mongodb/mongod.lock. probably means unclean shutdown recommend removing file and running --repair see: http://dochub.mongodb.org/core/repair for more information *************
Vamos agora a correção do problema:
sudo rm /var/lib/mongodb/mongod.locksudo -u mongodb mongod -f /etc/mongodb.conf --repair.sudo start mongodb. Verifique se o serviço está mesmo rodando(sudo status mondodb) e depois tente conectar a base de test(mongo test).Espero que isso ajude todos que tiverem o mesmo problema que eu.
Valeu galera e até a próxima!
novembro 23rd, 2011 | by suissa | mongodb
nov
23
Vou demonstrar como instalar o MongoDB no Linux (Ubuntu):
Abra o terminal e vamos instalar o MongoDB via apt-get:
sudo apt-get install mongodb
Agora precisamos criar 2 pastas:
sudo mkdir /data
cd /data
sudo mkdir db
sudo chown seu_usuario_linux db
PRONTO! Agora podemos rodar nosso MongoDB com o comando mongod para iniciar o serviço e com mongo nós abrimos o cliente no terminal.
Qualquer problema na instalação posta aqui nos comentários para que possamos ajudar.
ps: quase sempre é problema de permissão nas pastas.
novembro 14th, 2011 | by raymonsanches | mongodb, uncategorized
nov
14
A propriedade GridFS no MongoDB é indicada pra se trabalhar com um grande volume de arquivos e muitos acessos simultâneos. Ela também é ideal para trabalhar com arquivos maiores que 4MB.
Isso não quer dizer que ela não seja indicada para arquivos menores, muito pelo contrário. A diferença é que, em arquivos maiores que 4MB o GridFS automaticamente divide o arquivo em partes (ou chunks) praticamente automatizando o autosharding .Uma mão na roda.
Mas agora, vamos ao que interessa.
Por quê usar a propriedade GridFS?
Fazendo UPLOAD usando GridFS via MongoDB Driver
PHP::
// conectar ao mongo e a collection
$mongo = new Mongo();
$db = $mongo->teste;
// usando a clase GridFS
$grid = $db->getGridFS();
// caminho do arquivo a ser enviado
$caminho = "/tmp/";
// nome do arquivo
$arquivo = "imagem-teste.png";
// armazenando as informações de metadata do arquivo
$metadata = array(
"filename" => $arquivo,
"downloads" => 0,
"comment" => "Meu primeiro arquivo no Mongo"
);
$grid->storeFile($caminho . $arquivo, $metadata);
::PHP
Para que esse pequeno script funcione é preciso ter instalado o driver do MongoDB para o PHP e tê-lo inicializado. Este exemplo acima funciona perfeitamente utilizando forms multipart/form-data e $_FILES.
Metadata
Para o PHP o uso da Metadata não é de suma importância, porém em outras linguages esses dados são necessários. O MongoDB fornece essa opção fazendo que seus dados possam ser acessados por outras linguagens em outros dispositivos caso seja necessário. Você também pode inserir qualquer campo metadata que necessitar.
Resgatar um arquivo com GridFS
PHP::
// conectar ao mongo e a collection
$mongo = new Mongo();
$db = $mongo->teste;
// usando a clase GridFS
$grid = $db->getGridFS();
// procurando a imagem pelo nome
$imagem = $grid->findOne("imagem-teste.png");
// retorna imagem ao browser
header('Content-type: image/jpeg');
echo $image->getBytes();
::PHP
Nos próximos artigos vou comentar sobre os outros recursos da classe GridFS, que facilita muito a vida do desenvolvedor. Espero que tenham gostado do meu primeito post aqui no NoSQL BR e espero poder contribuir cada vez mais para que essa comunidade só venha a crescer. Um obrigado especial ao Suissa pelo espaço e enjoy 
novembro 3rd, 2011 | by Thiago Avelino | couchdb, mongodb, nosql
nov
03
“A motivação mais comum que leva as empresas a usar NoSQL é a escalabilidade. Mas se você lida com objetos complexos em sua aplicação, como entidades espalhadas em dezenas de tabelas normalizadas, pode ser que uma alternativa NoSQL seja útil para o seu projeto, mesmo que ele não tenha zilhões de usuários simultâneos”. Essa pertinente colocação levouLuciano Ramalho, supervisor de desenvolvimento na BIREME/OPAS/OMS e referência no mundo Python, a apresentar noNoSQLBr 2011 o case OpenTrials para o Registro Brasileiro de Ensaios Clínicos. Trata-se de uma plataforma virtual de acesso livre financiada pelo Ministério da Saúde, entre outras entidades, e que tem por finalidade registrar estudos experimentais e não-experimentais realizados em seres humanos, por pesquisadores brasileiros e estrangeiros.
Luciano conta que a missão dele e de sua equipe era a de renovar métodos, práticas e ferramentas de desenvolvimento. Como primeiro passo, o desafio foi migrar do “PHP sem framework” para Python com Django. E explicou em detalhes como foi realizado esse projeto, desde a criação, a partir de ferramentas open source e práticas ágeis, até as lições aprendidas no processo fazendo uso da persistência poliglota com um “mix” de BD relacional com banco de dados NoSQL, e a “solução” para o OpenTrials com o CouchDB (considerando que o MongoDB também seria apropriado para o projeto em questão).
Assista ao vídeo com a íntegra da palestra de Luciano Ramalho no NoSQLBr 2011:
http://www.gonow.com.br/blog/2011/11/02/modelos-ricos-outro-motivo-para-usar-nosql/
outubro 30th, 2011 | by Thiago Avelino | escalabilidade, java, mongodb, nosql, python
out
30
Edgar Silva é Solutions Architect Manager na Red Hat Brasil, responsável pelo time que define as tecnologias e soluções de plataformas Linux, middleware, virtualização e cloud computing. Na segunda edição do NoSQLBr, Edgar fez uma apresentação sobre o OpenShift, o PaaS da Red Hat, com demonstrações práticas de como utilizá-lo em conjunto com tecnologias como MongoDB e Infinispan para recurso de armazenamento de aplicações (que podem estar escritas em diversas linguagens, entre elas Python, PHP, Java e Ruby).
Edgar tem como missão na empresa pesquisar como combinar vários conceitos computacionais e de negócios para encontrar a solução mais adequada aos desafios de projetos propostos por seus clientes. “Até que ponto são relevantes questões como sistema operacional ou linguagem? As empresas querem ser bem atendidas, não importa muito tecnologia, linguagem ou sistema operacional. A questão está cada vez mais focada em negócios mesmo”, diz ele.
Com a “nova onda” de Cloud, várias soluções de PaaS surgem como alternativa para empreendedores e pequenos investidores atrairem negócios e transformar meras ideias em casos de sucesso. Projetos relacionados a dados públicos, jogos online em HTML5 para dispositivos móveis e geolocalização, entre outros, são casos de uso candidatos para começarem a ser desenvolvidos nesse tipo de infraestrutura – gratuita – como o OpenShift.
Assista ao vídeo com a íntegra da palestra de Edgar Silva no NoSQLBr 2011: clique aqui
Referência: Gonow Tecnologia - http://www.gonow.com.br/blog/2011/10/26/openshift-nosql-a-la-carte-em-um-paas-100-open-source/
junho 6th, 2010 | by suissa | mongodb, python
jun
06
Valentin Kuznetsov acaba de apresentar um trabalho na Conferência Internacional sobre Ciência Computacional sobre a utilização do CERN MongoDB para os dados do Large Hadron Collider. O papel, o CMS de agregação de dados do sistema, está disponível como um PDF no ScienceDirect.
Eles estão ansiosos para testá-lo em campo e escalar horizontalmente o sistema com sharding. Como se trata de uma grid aggregation/querying tool, eles também estão interessados na sua aplicação a problemas fora do LHC e o CERN.
maio 29th, 2010 | by suissa | mongodb, nosql
mai
29
Eu queria começar a aprender sobre NoSQL especificamente sobre o MongoDB e nada melhor como fazer algo na pratica. Passei por alguns momentos de dificuldade especialmente no update, já que era a primeira vez.
Eu fiz ele todo orientado a objetos, primeiro comecei com a conexão com o banco de dados
[php]
class conexao{
function __construct(){
$nome_banco = ‘prioridades’;
$nome_collection = ‘tarefas’;
$this->conexao = new Mongo();
$this->db = $this->conexao->$nome_banco;
$this->collection = $this->db->$nome_collection;
header (‘Content-type: text/html; charset=utf-8′);
}
}
[/php]
Sem muitos problemas aqui, a unica coisa, foi o utf8, pois tive alguns problemas de codificação na hora de inserir os dados, se você rodar esse código, ele já vai criar o banco e a collection automaticamente caso ela não exista.
O metodo de mostrar um registro especifico tem um segredinho, que é a criação de um MongoID, sem ele não consegui encontrar o registro. O findOne, só retorna 1 documento.
[php]
function mostrar($_id){
$mongo_id = new MongoID($_id);
return $this->collection->findOne(array(‘_id’ => $mongo_id));
}
[/php]
O metodo que usei para listar é bem simples
[php]
function listar($filter){
return $this->collection->find($filter);
}
[/php]
A parte de inserir um documento no banco de dados, foi bem fácil também. Para inserir, você coloca em um array todas as informações, o campo e o valor dele.
[php]
function inserir(){
$this->query = array(
‘UsuarioID’ => $this->UsuarioID,
‘Usuario’ => $this->Usuario,
‘Tarefa’ => $this->Tarefa,
‘Tipo’ => $this->Tipo,//Obrigatório, idéia, outro
‘Prioridade’ => $this->Prioridade
);
$this->collection->insert($this->query);
}
[/php]
O método de exclusão também não tem segredos, é só criar o MongoID que esta tudo certo
[php]
function excluir(){
$this->mongo_id = new MongoID($this->_id);
$this->collection->remove(array(‘_id’ => $this->mongo_id));
}
[/php]
Agora vamos lá, a parte que eu tive mais dificuldade que foi o update. No update, é preciso usar o $set para alterar um campo especifico da collection, sem ele, ele vai alterar o documento todo, vai remover todo o resto e vai manter apenas o campo que você passar ali. Uma dificuldade que eu tive, foi que o $set só funciona com aspas simples, com aspas duplas ele definitivamente não funcionou.
[php]
function mudar_tarefa(){
$this->mongo_id = new MongoID($this->_id);
$this->collection->update(array(‘_id’ => $this->mongo_id), array(‘$set’ => array(‘Tarefa’ => $this->Tarefa)), false);
}
function mudar_prioridade(){
$this->mongo_id = new MongoID($this->_id);
if($this->modo==’up’){
$this->collection->update(array(‘_id’ => $this->mongo_id), array(‘$inc’ => array(‘Prioridade’ => 1)), false);
}elseif($this->modo==’down’){
$this->collection->update(array(‘_id’ => $this->mongo_id), array(‘$inc’ => array(‘Prioridade’ => -1)), false);
}
}
[/php]
O $inc, serve para incrementar um valor em mais 1 ou menos 1, isso ai você pode especificar da maneira que você quiser. Lembrando que você tem que criar o MongoID para poder alterar o documento.
Essa ai é a classe que usei para fazer o sisteminha. As minhas dificuldades foram bobas, mas só vendo isso agora, pois não consegui encontrar em nenhum lugar sobre isso, principalmente sobre as aspas simples.
Ta aqui o download para quem quiser baixar.
http://www.megaupload.com/?d=5I0VX4I4
maio 20th, 2010 | by suissa | converter, mongodb, mysql, nosql, sql
mai
20
Notando que a maioria dos programadores PHP utilizam MySQL e para você começar a usar o MongoDB ncessita de uma base de dados para começar a programar sua funções, tive a idéia de criar um conversor simples de MySQL para MongoDB. Aqui vou explicar o seu código e como é simples utilizar o MongoDB com PHP.
Criei uma interface bem simples para que possamos enviar os dados sem precisar ficar mudando no código.
Interface do meu conversor
Essa interface enviará, via POST, as variáveis de conexão com o banco de dados MySQL.
$host = isset($_REQUEST['host_mysql']) ? $_REQUEST['host_mysql'] : “localhost”;
$user = isset($_REQUEST['user_mysql']) ? $_REQUEST['user_mysql'] : “usuario”;
$pass = isset($_REQUEST['pass_mysql']) ? $_REQUEST['pass_mysql'] : “senha”;
$db = isset($_REQUEST['db_mysql']) ? $_REQUEST['db_mysql'] : “teste_latin”;
Agora é hora de criar a conexão com o MongoDB utilizando uma extensão instalada no php: http://github.com/downloads/mongodb/mongo-php-driver/mongo-1.0.6-r1-php5.3vc6ts.zip
try{
$conexao = new Mongo(); //abre conexão com o MongoDB
$db_mongo = $conexao->$db; //cria a database com o mesmo nome do MySQL
}
catch(MongoConnectionException $e){
die(“<h1 class=’erro’>Erro do banco de dados MONGODB – Inicie o servidor do MongoDD!</h1><span class=’dica’>Dica: Entre no prompt do windows<br />
cd \ <br />
cd mongodb<br />
cd bin<br />
mongod </span>”);
}
Caso o seu MongoDB não esteja rodando o script indicará o erro e mostrará a forma como iniciar seu MongoDB no Windows.
Para conseguirmos pegar o nome de todas as tabelas da nossa database no MySQL utilizamos a seguinte query:
$query_pega_tabelas = “SHOW TABLES”;
O nome do nosso campo contendo as tabelas será:
$index_tabelas = “Tables_in_”.$db; //nome do array com o valor do nome das tabelas via SHOW TABLES
Onde a variável $db será o nome da nossa database no MySQL. Após pegarmos os nomes das nossas tabelas é hora de irmos tabela por tabela pegando seus dados e inserindo-os, não será necessário pegar os metadados(tipo, tamanho) dos campos pois o MongoDB não necessita dessas informações.
if($result_pega_tabelas=mysql_query($query_pega_tabelas)){
while($arr_pega_tabelas[] = mysql_fetch_assoc($result_pega_tabelas)){
}
$rs_charset=mysql_query($query_charset);
foreach($arr_pega_tabelas as $c=>$v){
if(is_array($v)){
foreach($v as $a => $b){
echo “<h3>Tabela: “.$b.”</h3>”;
$nome_tabela = $b;
$query_pega_dados = “EXPLAIN “.$nome_tabela;
if($result_pega_dados=mysql_query($query_pega_dados)){
$arr_pega_dados = array();
while($arr_pega_dados = mysql_fetch_assoc($result_pega_dados)){
$arr_totalis[$nome_tabela][] = $arr_pega_dados;
}//fim while
}//fim if query pega dados
}//fim foreach
}//fim if array
}//fim foreeach
Geramos uma collection para cada tabela existente no MySQL.
foreach($arr_totalis as $c => $v){
$query = ‘select * from ‘.$c;
$collection = $db_mongo->$c;
$rs_select = mysql_query($query);
echo “Inserindo em “.$c.”<br />”;
echo “<pre>”;
while($arr_dados = mysql_fetch_assoc($rs_select)){
Precisamos codificar nossos valores, assim como os campos, em utf8. Porém caso nosso banco já esteja em utf8 não será necessária a conversão. Para isso criei um pequena função utilizando iconv.
foreach($arr_dados as $c => $v){
$obj[utf8_encode_suissa($c)] = utf8_encode_suissa($v);
}//fim foreach
$arr[] = $obj;
}//fim while
$erro = 0;
No caso meu banco que será convertido está codificado em latin1, correspondente ao charset iso-8859-1. Essa função vai ao final do script.
function utf8_encode_suissa($s) {
return iconv(‘iso-8859-1′, ‘utf-8′, $s);
}
Após a conversão para utf8 inserimos o objeto codificado, com a função insert(), na nossa collection que terá o mesmo nome que a tabela correspondente no MySQL.
foreach($arr as $cc => $vv){
if(!$collection->insert($vv)){
echo “Não inseriu”.print_r($c) ;
$erro++;
$var_erro[] = var_dump($vv);
}//fim if
}//fim foreach
Caso tenha ocorrido algum erro mostrará-o com var_dump, só para ter uma noção de como os dados estão estruturados.
if($erro > 0){
echo “<h3>Aconteceram os seguintes erros:</h3>”;
foreach($var_erro as $f => $g){
var_dump($g);
}//fim foreach
}//fim if
echo “</pre>”;
}//fim foreach
}//fim if
Ao término do script você poderá entrar no phpMoAdmin, ferramenta para manipular as bases e as collections do MongoDB, e ver na lista das databases sua nova base criada.
phpMoAdmin
O scrip completo com a interface para inserir os dados se encontra em: http://www.nosqlbr.com.br/conversor_mysql_mongodb.zip
maio 14th, 2010 | by alex | cassandra, couchdb, escalabilidade, mongodb, mysql, nosql
mai
14
Aposto todas as minhas fichinhas que todos que quiseram estudar NoSQL ficaram na duvida de qual dos dois usar, MongoDB ou CouchDB, mesmo que tenha ido para um cassandra ou qualquer outro NoSQL.
A duvida fica muito maior, porque são dois banco de dados muito semelhantes(orientado a documentos) e bastante usados. Vou colocar aqui o meu relato sobre o MongoDB e o CouchDB.
Quando vi as possibilidades do NoSQL, o primeiro banco de dados que vi foi o CouchDB, fiquei louco para começar a aprender ele, fazer alguns projetos e tudo mais, porem, dei uma olhada muito rápida no site deles, e não vi uma versão pra Windows. Falem o que quiserem, mas muita, muita gente e todo mundo sabe disso, faz tudo no Windows e se não tiver uma versão pra ele, não vão usar, vão continuar com o MySQL.
Demorei meses para voltar para o NoSQL, mas sempre com aquela vontade de realmente aprender um desses novos bancos de dados. Voltando aquele tesão inicial em aprender o NoSQL, vi muitos códigos usando o CouchDB, muita gente usando, muitas coisas pela internet sobre ele. Isso foi um ponto forte pra mim em relação a outros, quando vi que o CouchDB era incubado pela Apache, a balança pesou mais um pouquinho.
Já que o NoSQL é uma técnologia extremamente nova, eu queria pensar a longo prazo, várias vezes fiquei me perguntando as vantagens entre esses bancos de dados. Confesso que quando vi uma pesquisa falando sobre os bancos de dados que as pessoas mais tinham vontade de aprender, apontando o CouchDB como segundo, ele ganhou mais um ponto, em primeiro vinha o cassandra, porem ele ainda não tinha instalação pra windows. O PHP é muito forte, e um dos fatores principais é a grande comunidade e excelente documentação que eles possuem, levei isso em consideração na hora da escolha do NoSQL.
O CouchDB vinha cada vez mais ganhando pontos comigo, mas na mesma pesquisa, o terceiro colocado era o MongoDB, resolvi olhar ele mais de perto, uma vez que queria dar o ponta pé inicial.
Cheguei para olhar o MongoDB só por olhar mesmo, só para ir pro CouchDB com a consciencia limpa. Lia alguma coisa sobre ele, já pensava, mas o CouchDB faz isso também. Mas uma coisa começou a me chamar a atenção, o MongoDB para instalar era só baixar no site e extrair em algum diretório. Isso me chamou a atenção, pois o CouchDB precisava de algumas dependencias para rodar. Logo baixei e instalei, naquele momento comecei a pensar mais sobre ele, um coraçãozinho cresceu.
Rodei uma linha de comando, e está lá, um NoSQL funcioando direitinho. Isso foi tão empolgante, que não achava que pudesse melhorar, olhei no site do MongoDB, e para rodar com o PHP bastava instalar uma DLL. Fui lá e instalei a dll.
A facilidade me encantou, porem ainda pesava a incubadora do CouchDB e todas os outros pontos. Analizando mais um pouco o CouchDB vi que era preciso vários includes para fazer ele funcionar com PHP, menos pontos pra ele, uma vez que o MongoDB se saiu muito bem nessa. Agora fui colocar lado a lado a documentação.
Não precisei olhar muito para saber o escolhido, na imensa documentação do php.net esta uma documentação para o MongoDB. Foi ali que parei de ler o CouchDB e ler sobre o MongoDB. MongoDB funcioando na minha maquina, documentação no php.net, documentação no próprio site do MongoDB era incrivel, não tive mais tempo para o CouchDB.
| N º de inserções |
Couch Tempo Total (seg) |
Couch / Doc (ms) |
Mongo Tempo Total (seg) |
Mongo / Doc (ms) |
| 1 | 0,0015 |
1,46 |
0,0005 |
0,5 |
| 2 | 0,0015 |
0,75 |
0,0004 |
0,2096 |
| 3 | 0,0017 |
0,56 |
0,0005 |
0,1604 |
| 4 | 0,0017 |
0,44 |
0,0005 |
0,1190 |
| 5 | 0,0018 |
0,36 |
0,0005 |
0,1060 |
| 6 | 0,0019 |
0,32 |
0,0006 |
0,0931 |
| 7 | 0,0021 |
0,3 |
0,0006 |
0,0847 |
| 8 | 0,0022 |
0,27 |
0,0007 |
0,0789 |
| 9 | 0,0023 |
0,25 |
0,0007 |
0,0734 |
| 10 | 0,0025 |
0,25 |
0,0007 |
0,0721 |
| 50 | 0,007 |
0,14 |
0,0024 |
0,0476 |
| 100 | 0,0136 |
0,14 |
0,0044 |
0,0442 |
| 500 | 0,0687 |
0,14 |
0,0253 |
0,0505 |
| 1000 | 0,1361 |
0,14 |
0,0372 |
0,0372 |
| 2500 | 0,4686 |
0,19 |
0,0278 |
0,0372 |
| 5000 | 0,9165 |
0,18 |
0,0488 |
0,0371 |
| 7500 | 1,5116 |
0,2 |
0,0835 |
0,0098 |
| 10000 | 2,3111 |
0,23 |
0,1065 |
0,0111 |
| 25000 | 6,8684 |
0,27 |
0,2711 |
0,0107 |
| 50000 | 15,8227 |
0,32 |
0,5430 |
0,0109 |
| 100000 | 35,3071 |
0,35 |
1,7697 | 0,0177 |
| 250000 | 104.0009 |
0,42 |
6,4533 |
0,0258 |
| 500000 | 230.6021 |
0,46 |
11,7684 |
0,0235 |
| 750000 | 352.7959 |
0,47 |
17,0473 |
0,0227 |
| 1000000 |
487.3284 |
0,49 |
18,4376 |
0,0184 |
Analisando os dados do gráfico e da tabela podemos perceber que o tempo real do MongoDB quase sempre esta uma casa(decimal) abaixo do CouchDB, ou seja, enquanto o CouchDB demora 0,0025 o Mongo DB, para o mesmo conjunto de instruções, demora 0,0007 segundos. E por conseguinte notamos que no final da inserção de 1 milhão de registros o CouchDB demora 487.3284 e o MongoDB 18,4376 segundos ao total. É um tempo considerável a se levar em conta
Posso ter puxado o saco do MongoDB, mas a facilidade de instalação, sem dependencias nem nada, só instalar uma dll no meu php e rodar, foi fator decisivo. No meio do caminho da comparação, o processo foi tão simples que parei por ali. Ao ver a documentação do php.net vi que ali o MongoDB tinha o apoio que eu esperava. Apesar de muitas pessoas estarem entrando no NoSQL indo direto pro CouchDB o MongoDB tem uma comunidade bastante forte, a facilidade dele como um todo é incrivel, isso conta muitos pontos.
Eu escolhi o MongoDB, mas vou estudar o CouchDB e o Cassandra. Eles são tão faceis, que quero aprender nem que seja um pouco de cada um deles, mas estou estudando a fundo o MongoDB.