Shell | Blog Patrick Espake

Posts Tagged ‘shell’

MongoDB do feijão a feijoada

Postado em 09 mar 2010
Categoria(s) MongoDB

Combina as melhores características de banco de dados documental, armazenamento de chave-valores e banco de dados relacional.

MongoDB é uma solução escalável, de alta performance, open source e banco de dados orientado a documentos. Escrito em C++, algumas características:

Armazenamento orientando a documentos (a simplicidade e poder do esquemas de dados em JSON);
Consultas dinâmicas;
Completo suporte a índices, extendo para objetos internos e arrays embutidos;
Rápido, para atualizações;
Eficiente armazenamento de dados binários, como: fotos e vídeos;
Auto-sharding alto nível de escabilidade na nuvem;
MapReduce para agregação complexa;
…

MongoDB é a ponte do fosso entre o armazenamento de chave-valores (que são rápidos e altamente escaláveis) e os tradicionais banco de dados relacionais (que fornecem esquemas estruturados e consultas poderosas).

Conceitos

Coleções

Coleções são essecialmente nomes de grupos de documentos. Você pode pensar nelas mais ou menos equivalente às tabelas do banco de dados relacional.

Estes documentos usualmente tem a mesma estrutura, mas isso não é um exigência do MongoDB o esquema de dados é livre. Você pode armazenar conjunto heterogêneo de documentos dentro de uma coleção, você não precisa predefinir “colunas” ou campos para as coleções.

Os nomes das coleções podem começar com letras, underscore ou podem incluir números; $ é reservado não podendo ser usado.

Documentos

Quando nós inserimos dados no MongoDB, os dados sempre são na forma de documentos. Documentos são uma estrutura de dados análogo ao JSON, dicionários em Python, e hashes em Ruby. Por exemplo:

doc = { author : 'joe', created : new Date('03-28-2009'), ... }

(BSON) Tipos de dados

MongoDB usa tipos de dados especiais além dos tipos básicos JSON de string, integer, boolean, double, null, array e object. Esses tipos incluem date, object id, dados binários, expressão regular e código.

Object IDs

Documentos no MongoDB são obrigados a ter uma chave, _id, única para a sua identificação.

Cada documento no MongoDB tem um campo _id como primeiro atributo. Esse valor usualmente é BSON ObjectId, sendo único para cada membro da coleção.

Se o usuário tentar inserir um documento sem fornecer um id, o banco de dados irá gerar automaticamente um _object id e armazená-lo no campo _id.

Usuários podem gerar suas próprias convenções para criação de ids; o valor para _id pode ser de qualquer tipo enquanto for único.

Instalação

http://www.mongodb.org/display/DOCS/Quickstart

Para iniciar o processo do MongoDB:

$ mongod

Conexão com o banco de dados

Você pode manipular o banco de dados através do shell JavaScript com:

$ mongo

Por padrão o shell conecta no banco de dados em localhost. Você verá:

MongoDB shell version: 1.2.2
url: test
connecting to: test
type "help" for help
>

“connecting to:” informa para você o nome do banco de dados que o shell está usando. Para mudar para outro banco de dados, digite:

> use mydb

Para ver toda a lista de comandos válidos, digite help.

Para os desenvolvedores mais experiêntes em outros banco de dados, você pode notar que nunca é criado o banco de dados ou coleção, MongoDB não solicita isso. Quando você inserir algo o MongoDB cria a coleção e o banco de dados. Se você consultar uma coleção que não existe o MongoDB trata como uma coleção vazia.

Inserindo dados em uma coleção

Para começar vamos criar uma coleção de teste e inserir alguns dados. Nós vamos criar dois objetos, j e t, e então salvar eles na coleção things.

> j = { name: "mongo" };
{ "name" : "mongo" }
> t = { x: 3 };
{ "x" : 3 }
> db.things.save(j);
> db.things.save(t);
> db.things.find();
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
>

Algumas coisas para notar:

Nós não temos uma coleção pré-definida. O banco de dados cria automaticamente na primeira inserção;
Os documentos que nós gravamos podem ter qualquer “estrutura” – na verdade nesse exemplo, os documentos não tem elementos de dados comum a todos. Na prática, usualmente os documentos tem a mesma estrutura dentro das coleções. No entando, esta flexibilidade significa que as migrações de esquema e de reposição são muito mais fáceis na prática – raramente você vai precisar escrever um script que executa operações do tipo “alter table”;
Ao ser inserido no banco de dados, os objetos são atribuídos a um identificador de objeto (se ele não tiver um) no campo _id;

Vamos adicionar mais alguns registros para esta coleção:

> for( var i=1; i < 10; i++) db.things.save({ x:4, j:i });
> db.things.find();
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }
>

Note que vamos ver os dois documentos adicionados no começo e mais os 9 novos documentos adicionados no loop for.

Acessando dados da consulta

Tecnicamente, find() retorna um objeto cursor, desta forma é possível iterar em cima dele em um loop while:

> var cursor = db.things.find();
> while (cursor.hasNext()) { print(tojson(cursor.next())); }
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }
>

O exemplo acima exibe o estilo de iteração usando o cursor. A funcão hasNext() informa se existe mais documentos para retornar, e a função next() retorna o próximo documento. Nós usamos o método tojson() para formatar os documentos para JSON.

Ao trabalhar com o shell JavaScript, também podemos usar os recursos da linguagem, e apenas chamar forEach para o cursor.

> db.things.find().forEach( function(x) { print(tojson(x));  } );
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }
>

Nesse caso do forEach() devemos definir uma função que é chamada para cada documento no cursor.

No shell do MongoDB, você pode tratar cursores como um array:

> var cursor = db.things.find();
> print (tojson(cursor[4]));
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }

Ao usar um cursor assim, note que todos os valores até o mais alto acessado (cursor[4] acima) são carregados na memória RAM ao mesmo tempo. Isso não é apropriado para grandes conjuntos de resultados, você pode ficar sem memória. Cursores devem ser usados com um iterador com qualquer consulta que retornar um grande número de elementos.

Também é possível converter o cursor para um array:

> var arr = db.things.find().toArray();
> arr[5];
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }

Por favor note que esses recursos de array são específicos do shell interativo do MongoDB, e não disponíveis em todos os drivers para MongoDB.

Especificando o que a consulta retorna

Agora que sabemos como trabalhar com cursores, podemos nós concentrar para as consultas retornarem coisas específicas.

Em geral, a maneira de fazer isso é criar “documentos de consulta”, que são documentos que indicam o padrão de chaves e valores que devem ser combinados.

Estes são mais fáceis demonstrar que explicar. No exemplos a seguir, vamos dar o exemplo da consulta SQL, e demonstrar a forma de representar a mesma consulta usando MongoDB através o shell. Esta maneira de consultas específicas é fundamental para MongoDB, assim que você vai encontrar a mesma facilidade em alguns driver ou linguagens.

SELECT * FROM things WHERE name="mongo"

> db.things.find({name:"mongo"}).forEach(function(x) { print(tojson(x)); } );
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }

SELECT * FROM things WHERE x=4

> db.things.find({x:4}).forEach(function(x) { print(tojson(x)); });
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "x" : 4, "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "x" : 4, "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "x" : 4, "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "x" : 4, "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "x" : 4, "j" : 9 }

A expressão de consulta é um documento em si. O documento de consulta é da forma { a:A, b:B, … } significa “where a==A and b==B and …”.

MongoDB também permite que você retorne “documentos parciais” – documentos que tenham apenas um subconjunto de elementos do documento armazenado em banco de dados. Para fazer isso, você adiciona um segundo argumento para a consulta find(), fornecendo um documento que enumera os elementos que devem ser devolvidos.

Para ilustar, vamos repetir o último exemplo find({x:4}) com o argumento adicional que limita o documento devolvido apenas com os elementos “j”:

SELECT j FROM things WHERE x=4

> db.things.find({x:4}, {j:true}).forEach(function(x) { print(tojson(x)); });
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "j" : 1 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "j" : 2 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0752"), "j" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0753"), "j" : 4 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0754"), "j" : 5 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0755"), "j" : 6 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0756"), "j" : 7 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0757"), "j" : 8 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0758"), "j" : 9 }

Note que o campo “_id” sempre é retornado.

findOne()

Por conveniência, o MongoDB shell (e outros drivers) permite evitar sobrecarga de programação de lidar com o cursor, e só permite recuperar um documento através da função findOne(). findOne() utiliza os mesmos parâmetros que a função find(), mas ao invés de retornar um cursor, ele irá retornar primeiro documento retornado do banco de dados, ou null se nenhum documento for encontrado com a consulta especificada.

Como exemplo, podemos recuperar um documento com o name==’mongo’. Há muitas maneiras de fazer isso, incluindo apenas chamar next() do cursor (após verificar se não é nulo, é claro), ou tratar o curso como um array e acessando o elemento zero.

No entando, o método findOne() é conveniente e eficiênte:

> var mongo = db.things.findOne({name:"mongo"});
> print(tojson(mongo));
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }

Isso é mais eficiênte porque que o cliente requisita um único objeto do banco de dados, assim menos trabalho é necessário pelo banco de dados e rede. Isso é equivalente a find({name:”mongo”}).limit(1);

Limitar o Result Set através de limit()

Você pode limitar a quantidade de resultados da consulta definindo o máximo de número de resultados para serem retornados através do método limit().

Isso é altamente recomendável por razões de desempenho, isso limita o trabalho que o banco de dados faz, e limita o montante de dados retornados pela rede. Por exemplo:

> db.things.find().limit(3);
{ "_id" : ObjectId("4b7f0f478dbe0e0f149e074e"), "name" : "mongo" }
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0750"), "x" : 4, "j" : 1 }

Índices

Índices podem melhorar o desempenho da consulta, muitas vezes damaticamente. É importante pensar sobre os tipos de consulta da sua aplicação que você possa definir índices relevantes. Atualmente criar índices no MongoDB é relativamente fácil.

Um índice é uma estrutura de dado em coleção sobre os valores dos campos especificados nos documentos de uma coleção. Essa estrutura de dados é usado pelo otimizador de consulta do MongoDB para classificar rapidamente e ordenar documentos em uma coleção. Formalmente, esses índices são implementados usando índices “B-Tree”.

No shell, você pode criar um índice chamando a função ensureIndex(), e fornecendo um documento que especifica uma ou mais chaves de índice. Como exemplo nós podemos criar um índice para os campos “j”:

> db.things.ensureIndex({j:1});

A função ensureIndex() apenas cria o índice se ele não existir.

Uma vez que uma coleção é indexada por uma chave, o acesso aleatório a uma consulta que combina com a achave específica é rápido. Sem o índice o MongoDB tem que passar por cada documento, verificando o valor da chave especificada na consulta:

> db.things.find({j:2}); // rápido - usando índice
{ "_id" : ObjectId("4b7f13c38dbe0e0f149e0751"), "x" : 4, "j" : 2 }
> db.things.find({x:3}); // lento - tem que verificar todos porque 'x' não tem índice
{ "_id" : ObjectId("4b7f0f4e8dbe0e0f149e074f"), "x" : 3 }

Chaves embutidas

Com MongoDB você pode indexar até mesmo uma chave dentro de um documento embutido. Por exemplo:

> db.things.ensureIndex({"address.city":1});

Documentos como chaves

Campos indexados pode ser de qualquer tipo, incluíndo documentos:

> db.factories.save( { name: "xyz", metro: { city: "New York", state: "NY" } } );
> db.factories.ensureIndex({metro:1});

Você não pode especificar a classificação e ordenação para uma chave de objeto, portanto, as chaves de objetos são úteis para recuperação aleatória, menos para acessos ordenados (para esse último, considere chave de índices compostos).

Índices de chaves compostas

Além de chave única para índices, MongoDB também suporta múltiplas chaves “compostas” para índices. Assim como nos índices simples você usa a função ensureIndex() para criar o índice, mas em vez de especificar somente uma chave, você pode especificar várias:

> db.things.ensureIndex({j:1, name:-1});

Ao criar um índice, o número associado com a chave específica a direção do índice, assim sempre deve ser 1 (ascedente) ou -1 (descendente). Direção não importa para índices de chave única ou para acesso aleatório, mas é importante se você estiver fazendo consultas amplas sobre índices compostos.

Se você tiver um índice composto em múltiplos campos, você pode usá-lo para consulta no subconjunto dos campos. Por exemplo, se você tiver o índice composto nos campos:

a, b, c

Você pode usá-lo em consulta para:

a, b

a, b, c

Índices únicos

MongoDB suporta índices únicos, o que garante que não existem documentos já inseridos, cujos valores para as chaves indexadas coincidem com os de um documento existente. Para criar um índice que garante que não existem dois documentos que têm os mesmos valores para x e j você pode fazer:

> db.things.ensureIndex({x:1, j:1}, {unique:true});

Chaves perdidas

Quando o documento é salvado na coleção com índices únicos, as chaves faltantes serão inseridas com valores nulo. Assim, não será possível a inserção de múltiplos documentos em falta com a mesma chave indexada.

> db.people.save({firstname: "Patrick", lastname: "Espake"});
> db.people.ensureIndex({firstname: 1}, {unique: true});
> db.people.save({lastname: "Smith"});
> db.people.save({lastname: "Jones"});
E11000 duplicate key errorindex: mydb.people.$firstname_1  dup key: { : null }
> db.people.find()
{ "_id" : ObjectId("4b841fdd07c6c3b400e7fe3e"), "firstname" : "Patrick", "lastname" : "Espake" }
{ "_id" : ObjectId("4b84200f07c6c3b400e7fe3f"), "lastname" : "Smith" }

Valores duplicados

O índice único não pode ser criado em uma chave que tem valores duplicados. Se você quiser criar o índice mesmo assim, mantendo o primeiro documento no banco de dados e apagando todos os outros documentos que tenha valores duplicados, adicione a opção dropDups.

> db.things.ensureIndex({firstname : 1}, {unique : true, dropDups : true})

Apagando índices

Para apagar todos os índices de uma coleção específica:

> db.collection.dropIndexes();

Para apagar um único índice:

> db.collection.dropIndex({x: 1, y: -1})

ReIndex

O comando reIndex vai reconstruir todos os índices da coleção:

> db.myCollection.reIndex()

Usualmente isso é desnecessário. Você pode pedir para fazer se o tamanho da sua coleção mudou drasticamente ou o espaço em disco usado pelos índices parece estranhamente grande.

Desempenho dos índices

Índices fazem a busca por chave, incluíndo a recuperação sequencial ordenada, muito rápido. Atualizações por chave são rápidas também, MongoDB pode buscar o documento e atualizar rapidamente.

No entanto, tenha em mente que cada índice criado adiciona uma certa quantidade de sobrecarga para as inserções e exclusões. Além de escrever dados na base de coleções, as chaves devem ser adicionadas aos índices B-Tree. Assim, índices são melhores para coleções onde o número de leituras e muito maior que o número de escritas. Para coleções que são escritas intensamente, índices, em alguns casos podem ser anti-produtivos. A maioria das coleções são de leitura intensa, por isso os índices são uma coisa boa na maioria das situações.

Usando sort() sem um índice

Você pode usar sort() para retornar dados em ordem sem um índice, se o conjunto de dados a ser devolvido é pequeno (menor que quatro megabytes). Para outros casos é melhor user limit() e sort() juntos.

Multikeys

MongoDB fornece um interessante recurso “multikey” que pode automaticamente indexar arrays de valores de um objeto. Um bom exemplo são tags. Suponha que você tenha um artigo com tags que sejam alguns nomes de categorias:

> db.articles.save({ name: "Warm Weather", author: "Steve", tags: ['weather', 'hot', 'record', 'april'] });
> db.articles.find()                                                           
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }

Nós podemos facilmente executar uma consulta à procura de um determinado valor no array de tags:

> db.articles.find({ tags: 'april' })
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }

Além disso, nós podemos indexar o array de tags. Criando um índice no array de elementos de resultados na indexação do banco de dados indexando cada elemento do array:

> db.articles.ensureIndex( { tags: 1 } )
> db.articles.find( { tags: 'april' } )
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }
> db.articles.find( { tags: 'april' } ).explain()
{
	"cursor" : "BtreeCursor tags_1",
	"startKey" : {
		"tags" : "april"
	},
	"endKey" : {
		"tags" : "april"
	},
	"nscanned" : 1,
	"n" : 1,
	"millis" : 0,
	"oldPlan" : {
		"cursor" : "BtreeCursor tags_1",
		"startKey" : {
			"tags" : "april"
		},
		"endKey" : {
			"tags" : "april"
		}
	},
	"allPlans" : [
		{
			"cursor" : "BtreeCursor tags_1",
			"startKey" : {
				"tags" : "april"
			},
			"endKey" : {
				"tags" : "april"
			}
		}
	]
}

Campos de objeto embutido em um array

Além disso, a mesma técnica pode ser usado para campos em objetos embutidos:

> db.posts.save( { title: "How the west was won", comments: [ { text: "great!", author: "sam" }, { text: "ok", author: "julie" } ] } )
> db.posts.find( { "comments.author": "julie" } )                               
{ "_id" : ObjectId("4b84310707c6c3b400e7fe44"), "title" : "How the west was won", "comments" : [
	{
		"text" : "great!",
		"author" : "sam"
	},
	{
		"text" : "ok",
		"author" : "julie"
	}
] }

Consultado todos os valores definidos em um conjunto determinado

Ao utilizar a opção $all na consulta, um conjunto de valores podem ser fornecidos os quais devem estar presentes em um campo de objeto correspondente. Por exemplo:

> db.articles.find( { tags: { $all: ['april', 'record'] } } )
{ "_id" : ObjectId("4b842cad07c6c3b400e7fe42"), "name" : "Warm Weather", "author" : "Steve", "tags" : [ "weather", "hot", "record", "april" ] }
> db.articles.find( { tags: { $all: ['april', 'june'] } } )  
> // nada encontrado

Skip e Limit

MongoDB também suporta skip e limit para paginação fácil. Aqui podemos ignorar os 10 primeiros documentos, e limitar o nosso conjunto de resultados para 20:

> db.things.find({}, {}, 10, 20)

Consultas avançadas

Operadores condicionais: <, <=, >, >=

Use essas formas especiais para comparações maior que e menor que em consultas, desde que eles possam ser representandos em documentos de consulta:

> db.collection.find({ "field" : { $gt: value } } ); // maior que  : campo > valor
> db.collection.find({ "field" : { $lt: value } } ); // menor que  :  campo < valor
> db.collection.find({ "field" : { $gte: value } } ); // maior que ou igual : campo >= valor
> db.collection.find({ "field" : { $lte: value } } ); // menor que ou igual : campo <= valor

Por exemplo:

> db.things.find( { j: { $lt: 3 } } );
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }
> db.things.find( { j: { $gte: 4 } } ); 
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }
{ "_id" : ObjectId("4b856c065b4e024e99277722"), "x" : 10, "j" : 5 }
{ "_id" : ObjectId("4b856c065b4e024e99277723"), "x" : 10, "j" : 6 }

Você pode combinar esses operadores para intervalos específicos:

> db.things.find( { j: { $gt: 3, $lt: 6  } } )
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }
{ "_id" : ObjectId("4b856c065b4e024e99277722"), "x" : 10, "j" : 5 }

Operador condicional: $ne

Use $ne para “não igual”:

> db.things.find( { j: { $ne: 2 } } )  
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e99277720"), "x" : 10, "j" : 3 }
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }

Operador condicional: $in

O operador $in é análogo ao modificador SQL IN, permite que você especifique um array de combinação:

> db.things.find( { j: { $in: [2, 4, 6] } } )
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }
{ "_id" : ObjectId("4b856c065b4e024e99277721"), "x" : 10, "j" : 4 }
{ "_id" : ObjectId("4b856c065b4e024e99277723"), "x" : 10, "j" : 6 }

Operador condicional: $nin

O operador $nin é similar ao $in exceto que seleciona objetos que não tem nenhum valor especificado no array. Por exemplo:

> db.things.find( { j: { $nin: [2,4,6] } } );
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e99277720"), "x" : 10, "j" : 3 }
{ "_id" : ObjectId("4b856c065b4e024e99277722"), "x" : 10, "j" : 5 }
{ "_id" : ObjectId("4b856c065b4e024e99277724"), "x" : 10, "j" : 7 }

Operador condicional: $mod

O operador $mod permite que você faça consultas rápidas usando módulo:

> db.things.find( { j: { $mod: [ 10, 1 ] } } ) // this.a % 10 == 1
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e99277728"), "x" : 10, "j" : 11 }
{ "_id" : ObjectId("4b856c065b4e024e99277732"), "x" : 10, "j" : 21 }

Operador condicional: $all

O operador $all é similar ao $in, mas ao invés combinar qualquer valor do array, deve combinar todos os valores especificados no array. Por exemplo, o objeto:

{ a: [1, 2, 3] }

Deve combinar com:

db.things.find( { a: { $all: [ 2, 3 ] } } );

mas não com:

db.things.find( { a: { $all: [ 2, 3, 4 ] } } );

Operador condicional: $size

O operador $size permite especificar o tamanho de um array, ou seja, a quantidade de elementos:

> db.things.find( { j: { $size: 1 } } )
{ "_id" : ObjectId("4b8580965b4e024e99277781"), "j" : [ 99 ] }
{ "_id" : ObjectId("4b85809b5b4e024e99277782"), "j" : [ 999 ] }
{ "_id" : ObjectId("4b85809e5b4e024e99277783"), "j" : [ 9999 ] }
{ "_id" : ObjectId("4b8580a15b4e024e99277784"), "j" : [ 99990000 ] }

Operador condicional: $exists

Verifica pela existência (ou ausência) de um campo:

> db.things.find( { a: { $exists: true } } )
> db.things.find( { a: { $exists: false } } )
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }

Expressões regulares

Você pode usar expressões regulares para consultas:

> db.customers.find( { name : /acme.*corp/i } );

Valores em um Array

Você pode buscar todas as coleções que possuam a cor vermelha no array de cores:

> db.things.find( { colors : "red" } );

Operador condicional: $elemMatch

Use $elemMatch para verificar se um elemento no array combina com a expressão de combinação especificada:

> db.things.find( { x: { $elemMatch: { a:1, b: { $gt: 1 } } } } )

Operador meta: $not

O operador meta $not pode ser usado para negar a verificação realizada por um operador padrão. Por exemplo:

> db.things.find( { x: { $not: { $mod: [10, 1] } } } );

Expressão de linguagem e $where

Além da sintaxe estruturada de consulta mostrada até agora, você pode escrever consultas com a expressão “where” no estilo SQL.

> db.things.find( { $where: "this.j < 3" } )
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }
> db.things.find("this.j < 3")              
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }
{ "_id" : ObjectId("4b856c065b4e024e9927771f"), "x" : 10, "j" : 2 }

sort()

sort() é análogo ao ORDER BY no padrão SQL. Em MongoDB o valor 1 indica a ordem crescente e o -1 indica a ordem descrecente.

> db.things.find().sort( { x:1 } ) // classifica em ordem crescente
> db.things.find().sort( { x:-1 } ) // classifica em ordem decrescente

limit()

limit() é análogo ao LIMIT no padrão SQL. Especifica a quantidade máxima de resultados devolvidos.

> db.things.find().limit(2)
{ "_id" : ObjectId("4b856c065b4e024e9927771d"), "x" : 10, "j" : 0 }
{ "_id" : ObjectId("4b856c065b4e024e9927771e"), "x" : 10, "j" : 1 }

count()

O método count() retorna o número de objetos que combinam com a consulta especificada.

> db.things.find( { j: { $mod: [2, 0] } } ).count()
53
> db.mycollection.count( { active:true } )

Elemento do array por posição

Os elementos do array também pode ser acessados por sua posição específica:

// exemplo: comments[0].by == "Abe"
> db.blogposts.find( { "comments.0.by" : "Abe" } )

Operações OU em expressões de consultas

Objetos de consulta em MongoDB por padrão usam expressão AND para junção. MongoDB atualmente não incluem nenhum operador OR para consultas, entretanto existe algums modos de expressar isso em consultas.

> db.mycollection.find( { $where : function() { return this.a == 3 || this.b == 4; } } );
> db.mycollection.find( function() { return this.a == 3 || this.b == 4; } );
> db.things.find("this.j == 1 || this.j == 3")

Distinct

Devolve a lista de valores distintos para a chave na coleção:

> db.addresses.save({"zip-code": 10010})
> db.addresses.save({"zip-code": 10010})
> db.addresses.save({"zip-code": 99701})
> db.addresses.distinct("zip-code");
[ 10010, 99701 ]

distinct também pode ser usado para chaves aninhadas:

> db.comments.save({"user": {"points": 25}})
> db.comments.save({"user": {"points": 31}})
> db.comments.save({"user": {"points": 25}})
> db.comments.distinct("user.points");
[ 25, 31 ]

Atualizando documentos

Vamos criar um documento para depois atualizar:

db.users.save({name: 'Johnny', languages: ['ruby', 'c']});

Para atualizar o documento:

db.users.update({name: 'Johnny'}, {name: 'Cash', languages: ['english']});

Operadores de atualização

MongoDB suporta atualizações parciais de documentos. Por exemplo, você pode definir um valor:

db.users.update({name: 'Cash'}, {'$set': {'age': 50} });

É possível adicionar e remover itens dos arrays:

db.users.update({name: 'Sue'}, {'$pull': {'languages': 'scala'} });
db.users.update({name: 'Sue'}, {'$push': {'languages': 'ruby'} });

Apagando Dados

Para apagar tudo da coleção:

db.scores.remove();

Para apagar os documentos que casam com uma consulta:

db.users.remove({name: 'Sue'});

Tags: alta performance, atualização, características, coleção, conceitos, conexão, consulta, documental, documento, escalável, índices, inserção, insert, instalação, JavaScript, mongo, mongod, MongoDB, open source, operadores, remove, shell, update

Instalação do PostgreSQL

No Comments

Postado em 09 nov 2009
Categoria(s) PostgreSQL

Instalação

Para instalar o PostgreSQL no Ubuntu digite o comando:

sudo apt-get install postgresql-common postgresql-8.3 postgresql-client-8.3

Mudando a senha do usuário postgres

sudo su postgres psql

No console do psql

ALTER USER postgres WITH PASSWORD 'postgres';
\q

Configurando o postgresql.conf

sudo vi /etc/postgresql/8.3/main/postgresql.conf

Localizar a linha:

listen_addresses = 'localhost'

e mudar para:

listen_addresses = '*'

remova o carácter de comentário (#) da linha.

A opção listen_addresses permite definir qual host pode se conectar no servidor, exemplo: localhost somente para conexões locais, * para qualquer host ou um ip específico como: 192.168.1.236.

Configurando pg_hba.conf

sudo vi /etc/postgresql/8.3/main/pg_hba.conf

Adicionar no fim do arquivo a linha:

host all all 192.168.1.0/24 md5

Essa configuração específica na ordem:

host: Define regras para o protocolo TCP/IP, essa opção pode ser host, local ou hostssl;
all: Define qual banco de dados que essa regra se aplica, se definindo all será para todos;
all: Define qual usuário tem permissão para usar essa regra, se definido all será para todos;
192.168.1.0/24: Padrão CIDR, define qual faixa de ip’s podem ser conectar no servidor através do padrão CIDR;
md5: Método de autenticação, md5 padrão, trust para aceitar, reject para negar e mais algumas outras opções.

Reiniciar o PostgreSQL

sudo /etc/init.d/postgresql-8.3 restart

Usuários de banco de dados

Criar um novo usuário. Para pode criar um novo usuário é necessário estar logado com o usuário postgres.

sudo su postgres

Existem duas formas de criar e deletar um usuário, uma através do shell e outra através do cliente postgre.

Via Shell

createuser patrick

Via cliente postgres

psql
CREATE USER patrick;

As duas opções criam patrick como superusuário.

Exemplos:

Definindo password

CREATE USER patrick PASSWORD '123';

Definindo privilégios de superusuário, permissão para criar databases e roles:

CREATE USER patrick SUPERUSER INHERIT CREATEDB CREATEROLE;

Mais informações: http://pgdocptbr.sourceforge.net/pg80/sql-createuser.html.

Deletar usuário

Via Shell:

dropuser patrick

Via cliente postgres:

psql
DROP USER patrick;

Alterar usuário:

ALTER USER patrick PASSWORD ‘teste123′;

Mais detalhes: http://pgdocptbr.sourceforge.net/pg80/sql-alteruser.html.

Tags: alter user, apt-get, bash, cliente, comando, configurando, createdb, createrole, deletar, dropuser, exemplo, host, inherit, instalação, listen_addresses, md5, password, php_hba.conf, postgres, PostgreSQL, postgresql-8.3, postgresql-client-8.3, postgresql-common, postgresql.conf, psql, senha, shell, SQL, su, superuser, Ubuntu

Usando o Vim para Programar em Ruby on Rails

20 Comments

Postado em 21 abr 2009
Categoria(s) Ruby on Rails

Como todas as pessoas que procuram desenvolver com qualidade e agilidade, eu tive a minha saga até encontrar uma boa ferramenta de edição de código.

Eu só trabalho usando Linux, com certeza ele é o sistema operacional mais produtivo para trabalhar com desenvolvimento em tecnologias livres, para programar em PHP, Ruby on Rails, Java, Python e outras é uma maravilha. A quantidade de softwares e coisas legais é imensa.

Nessa minha saga e evolução no mundo dos editores/IDE já usei Dreamweaver, Gedit, Geany, Eclipse, Aptana, Komodo, Bluefish e por último o NetBeans. Sempre tinha alguns detalhes neles que acabava me irritando, algo que eles não conseguiam fazer. Alguns tinham tantos recursos que acabavam sendo pesados demais. Por último eu estava usando o NetBeans, ele tem umas sacadas legais e algumas coisas divertidas, mas é absurdamente pesado, outro detalhe é que algumas IDE’s tem a mania descontrolada de querer fazer tudo através de interface gráfica, trilhões de janelas para fazer coisas super simples, o terminal é um lance necessário em uma IDE, muitas coisas podem ser feitas em secundos através de um shell. Não a nada de errado em usar o shell, graças a ele que a produtividade aumenta muito, quem acha que interface gráfica aumenta a produtividade está enganado, as vezes ela só enrola mais as coisas.

Através de toda essa saga acima eu acabei chegando no VIM, usando especificamente o Gvim no Gnome para desenvolver em Ruby on Rails. Até o presente momento só são ótimas opiniões formadas sobre ele.

Nesse post vou mostrar como ganhar mais produtividade usando o Gvim.

Todos os passos abaixo foram feitos no Ubuntu 8.04, por que no Ubuntu? Porque ele é simples, tem uma porção de distribuições Linux por ae que complicam demais as coisas, o Ubuntu é sucesso porque é simples de usar. Existe uma grande chance de coisas simples fazerem mais sucesso que as coisas complicadas. :-)

Instalação do Gvim

1	sudo apt-get install vim vim-gnome vim-addon-manager vim-common vim-full vim-gtk vim-gui-common vim-rails vim-ruby vim-runtime vim-tiny exuberant-ctags ncurses-term

Instalação do Git

1	sudo apt-get install git

Instalação da gem para busca de arquivos

Essa gem está no github, desta forma é necessário adicionar o seu repositório: gem sources -a http://gems.github.com

1	sudo gem install jamis-fuzzy_file_finder

Instalação do pacote de configurações para o vim

Agora vamos instalar um pacote de configurações prontas para o vim, esse pacote foi criado pelo Fabio Akita, esse pacote já tem uma série de plugins, temas e snippets.

1	git clone git://github.com/akitaonrails/vimfiles.git ~/.vim

Você precisa criar o arquivo ~/.vimrc e adicionar o conteúdo abaixo:

source ~/.vim/vimrc
 
colorscheme vibrantink
set nu
set sts=2
set sw=2
let g:fuzzy_ignore = "gems/*"

Essas configurações irão fazer o número de linhas aparecer, ignorar os diretórios de gems e outros ajustes.

Os snippets estão em um repositório separado, desta forma precisamos obter esses arquivos, faça os passos abaixo:

1
2
3

cd ~/.vim
git submodule init
git submodule update

Existe um outro ajuste que pode ser feito, mas esse é opcional, da forma como está agora sempre irá aparecer um $ no final de cada linha, para marcar o fim, particularmente eu não gosto disso. Se você quiser é possível retirar essa marcação, edite o arquivo ~/.vim/vimrc procure pelas linhas:

1 2	"display tabs and trailing spaces set list

E deixe a configuração set list comentada, desta forma:

1 2	"display tabs and trailing spaces "set list

Feito isso nós já temos uma nova gama de funcionalidades adicionadas ao vim, mas é possível melhorar mais ainda, vamos agora instalar a fonte Monaco usada no TextMate. Essa fonte deixa o código com um visual legal.

Instalação da fonte Monaco

cd /usr/share/fonts/truetype
sudo mkdir myfonts
cd myfonts
sudo wget http://www.gringod.com/wp-upload/software/Fonts/Monaco_Linux.ttf
sudo chown root.root *.ttf
sudo mkfontdir
cd ..
fc-cache

Agora se você digitar no terminal:

gvim

Vai ver o gvim com a fonte Monaco e o tema desert.

Com o gvim aberto vamos criar um projeto em Ruby on Rails, e ver as funcionalidades novas que temos no vim. Graças ao plugin rails.vim (http://rails.vim.tpope.net/) foram adicionadas uma série de features.

Criando um projeto Ruby on Rails

Digite no gvim:

1	tecla esc + :Rails autocomplete

Onde autocomplete é o nome da minha aplicação Ruby on Rails nesse exemplo.

A opção irá criar a aplicação com suporte ao banco de dados SQLite, se você quiser suporte ao outro banco de dados digite:

tecla esc + :Rails autocomplete -d mysql
ou
tecla esc + :Rails autocomplete -d postgresql
...

Esse comando irá criar uma aplicação Ruby on Rails nova.

Pressione a tecla enter como informado na mensagem.

O plugin rails.vim é bem esperto, ele já vai abrir para você o database.yml para você configurar o banco de dados:

Pressione a tecla i ou insert para editar os dados, faça as alterações necessárias e salve digitando:

1	tecla esc + :w

Uma breve descrição sobre as operações básicas do vim:

tecla esc + :w serve para salvar sua alteração (write)
tecla esc + :q serve para fechar o arquivo (quit)
tecla esc + :x serve para salvar e fechar o arquivo

Criando o banco de dados

1	tecla esc + :Rake db:create

Pressione a tecla enter como informado na mensagem.

Criado um scaffold

1	tecla esc + :Rgenerate scaffold car name:string description:text color:string

Será gerado o scaffold para o model car, logo em seguida será exibido o cars_controller.rb:

Rodando as migrações

1	tecla esc + :Rake db:migrate

Visualizando a aplicação

Caso você queira visualizar aplicação nesse momento, você pode inicializar o servidor e ver um preview da aplicação rodando no navegador:

Inicializando o servidor

1	tecla esc + :Rserver

Vendo preview no navegador

1	tecla esc + :Rpreview

Nesse momento o gvim ficará travado e o navegador será aberto para você visualizar o andamento do projeto, quando você fechar o navegador o gvim será destravado.

Navegação de arquivos

Eu conheço duas formas de navegação de arquivos, a primeira é muito rápida:

1	tecla esc + ctrl + f

Digite o nome do arquivo desejado, por exemplo new:

A outra forma de navegação é em diretórios, digite:

1	tecla esc + :Vex

Snippets

Esse pacote que instalamos para o vim, tem muitos snippets já configurados para acelerar a condificação, eles podem ser encontrados no diretório ~/.vim/snippets:

Se você olhar nesses diretórios vai poder descobrir as siglas para acessar o snippets, dê uma boa olhada e teste.

Vamos testar um pouco os snippets, agora que você já sabe procurar arquivos, abra o arquivo car.rb:

1
2
3

tecla esc + ctrl + f
digite car.rb
enter

Digite i ou insert para colocar o gvim em modo de edição e digite:

1	vp + tecla tab

Agora e só apertar tab e ir substituindo os valores.

Caso o snippet não funcione, feche o gvim, acesse o diretório da aplicação Ruby on Rails (autocomplete), estando dentro do diretório autocomplete abra o gvim, agora os snippets tem que funcionar.

A ideia desse post é apenas dar um visão geral, existe várias outras coisas possíveis de fazer, e muitos outros comandos poderosos para trabalhar com Ruby on Rails no vim, por isso eu sugiro que você leia esses outros artigos:

http://www.akitaonrails.com/2009/01/03/rails-on-vim tem um vídeo bem legal, você pode ver a coisa funcionando na prática;
http://eustaquiorangel.com/blog/show/339 outros comandos usando o plugin rails.vim;
http://rails.vim.tpope.net/ site oficial do rails.vim;
http://code.google.com/p/vimbook/downloads/list livro grátis sobre o vim.

Se você gostou desse texto e acha que ajudou você, me recomende: .

Tags: :q, :Regenerate, :Rpreview, :Rserver, :Vex, :w, :x, agilidade, akitaonrails, apt-get, aptana, bluefish, car, cd, clone, configuração, configurações, controller, db:create, db:migrate, dreamweaver, eclipse, editor, Fabio Akita, fc-cache, ferramenta, fonte, geany, gedit, git, gvim, ide, instalação, install, jamis-fuzzy_file_finder, komodo, Linux, livro, mkdir, mkfontdir, model, monaco, netbeans, opera, pacote, Plugin, Plugins, programar, qualidate, rails, rails.vim, rake, Ruby, Ruby on Rails, saga, scaffold, shell, Snippets, sudo, tecla esc, terminal, truetype, Ubuntu, usando, view, vim, vim-addon-manager, vim-common, vim-full, vim-gnome, vim-gtk, vim-gui-common, vimfiles, vimrc

Blog Patrick Espake