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

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'});

O que aconteceu na internet em 2009?

Quantos sites foram adicionados? Quantos e-mails foram enviados? Quantos usuários estavam na Internet? Esse post vai responder essas questões e muitas outras. Prepara-se para a sobrecarga de informações, mas em um bom caminho. ;-)

Divirta-se!

JESS3 / The State of The Internet from JESS3 on Vimeo.

E-mail

• 90 trilhões – O número de e-mails enviados na Internet em 2009;
• 247 bilhões – Número médio de mensagens de e-mail por dia;
• 1,4 bilhões – O número de usuários de e-mail em todo o mundo;
• 100 milhões – Novos usuários de e-mail desde o ano anterior;
• 81% – A percentagem de e-mails que eram spam;
• 92% – Pico do nível de spam no final do ano;
• 24% – Aumento de spam desde o ano passado;
• 200 bilhões – O número de e-mails de spam por dia (supondo que 81% são spam).

Sites

• 243 milhões – O número de sites a partir de dezembro de 2009;
• 47 milhões – Sites adicionados em 2009.

Servidores web

• 13,9% – O crescimento de sites Apache em 2009;
• -22,1% – O crescimento de sites IIS em 2009;
• 35,0% – O crescimento de sites Google GFE em 2009;
• 384,4% – O crescimento de sites Nginx em 2009;
• -72,4% – O crescimento de sites Lighttpd em 2009.

Nomes de domínio

• 81,8 milhões – Nomes de domínios .COM no final de 2009;
• 12,3 milhões – Nomes de domínios .NET no final de 2009;
• 7,8 milhões – Nomes de domínios .ORG no final de 2009;
• 76,3 milhões – O número de códigos de países no top-level de domínios (ex: .CN, .UK, .DE, etc.);
• 187 milhões – O número de nomes de domínios em todo top-level de domínios (Outubro de 2009);
• 8% – Aumento de nomes de domínios desde o ano anterior.

Usuários da Internet

• 1,73 bilhões – Usuários da Internet em todo o mundo (Setembro 2009);
• 18% – Crescimento de usuários da Internet desde o ano anterior;
• 738.257.230 – Usuários da Internet na Ásia;
• 418.029.796 – Usuários da Internet na Europa;
• 252.908.000 – Usuários da Internet na América do Norte;
• 179.031.479 – Usuários da Internet na América Latina e Caribe;
• 67.371.700 – Usuários da Internet na África;
• 57.425.046 – Usuários da Internet no Oriente Médio;
• 20.970.490 – Usuários da Internet na Oceania / Austrália.

Midia Social

• 126 milhões – O número de blogs na Internet (rastreados pelo BlogPulse);
• 84% – Porcentagem de sites de rede social com mais mulheres do que homens;
• 27,3 milhões – Número de tweets no Twitter por dia (Novembro de 2009);
• 57% – Percentagem de usuários do Twitter localizados nos Estados Unidos;
• 4,25 milhões – Pessoas seguindo @aplusk (Ashton Kutcher, usuário mais seguido do Twitter);
• 350 milhões – Pessoas no Facebook;
• 50% – Porcentagem de usuários do Facebook que logam todos os dias;
• 500.000 – O número de aplicativos ativos no Facebook.

Imagens

• 4 bilhões – Fotos armazenadas pelo Flickr (Outubro de 2009);
• 2,5 bilhões – Fotos enviadas a cada mês para o Facebook;
• 30 bilhões – Ao ritmo atual, o número de fotos enviadas para o Facebook por ano.

Vídeos

• 1 bilhão – O número total de vídeos nos servidores do YouTube em um dia;
• 12,2 bilhões – Vídeos vistos por mês no YouTube nos Estados Unidos (Novembro de 2009);
• 924 milhões – Vídeos vistos por mês no Hulu nos Estados Unidos (Novembro de 2009);
• 182 – O número de vídeos online na média que um usuário assiste em um mês (EUA);
• 82% – Percentagem de usuários da Internet que assistem vídeos online (EUA);
• 39,4% – Vídeos publicitários armazenados no YouTube(USA);
• 81,9% – Porcentagem de vídeos embutidos em blogs que são vídeos do YouTube;

Navegadores web

Softwares maliciosos

• 148.000 – Novos computadores zumbis criados por dia (usados em botnets para enviar spam, etc.);
• 2,6 milhões – Quantidade de códigos maliciosos rodando no início de 2009 (vírus, trojans, etc.);
• 921.143 – O número de novas assinaturas de códigos maliciosos adicionados pela Symantec em Q4 2009.

Fonte: http://royal.pingdom.com/2010/01/22/internet-2009-in-numbers/.

Sobre o Jogo

Galaxis Farm é um jogo de gerenciamento de tempo para plataforma Adobe Flash. Está sendo desenvolvido com a engine Flixel (http://www.flixel.org) e pode ser modificado via scripting em linguagem Lua (http://www.lua.org).

O objetivo principal deste jogo é administrar uma fazenda. É um jogo ecológico. Desta forma, o jogador também deve ser preocupar com os requisitos ambientais, atendendo, por exemplo, às legislações pertinentes de: reserva legal, mata ciliar, destinação de carcaças e tratamento de dejetos.

Lançado, inicialmente, para o “Concurso de Jogos em Software Livre” da Latinoware 2009 (http://www.latinoware.org/node/76), este jogo também serve como teste de conceito para a criação de jogos em software livre voltados para a plataforma Web.

Desenvolvido, portanto, com ferramentas livres, não é necessária a utilização de compiladores ou ferramentas de edição proprietárias do Adobe Flash. Pode ser compilado e modificado utilizando-se o editor aberto FlashDevelop e o framework OpenSource Flex SDK.

Equipe envolvida, Divisão de Inteligência Artificial do TECPAR:

Como Jogar

Para jogar uma versão beta (preliminar) acesse: http://www.galaxisfarm.com/beta/ ou faça o download da versão executável: http://galaxisfarm.com/wp-content/uploads/beta_galaxisfarm.exe

Código Fonte

O código fonte do jogo está disponível no Google Code em: http://code.google.com/p/galaxisfarm/

Versão Beta

Atualmente o jogo está disponível na versão beta, essa versão possui as seguintes limitações:

• Colisão imperfeita do personagem com as construções;
• Imagens de botões simples;
• Efeitos visuais simples;
• Não possui ranking;
• Problemas nos descartes de vacas mortas.

Próxima Versão

Estamos trabalhando na nova versão do jogo, nessa versão pretendemos usar a última versão da game engine Flixel, que aparentemente trabalha melhor com colisões, também vamos melhorar as imagens e efeitos visuais.

Sobre a Game Engine Flixel

É uma biblioteca Actionscript (Flash) livre, destinada para uma grande variedade de jogos em Flash. Inclui ganchos para gravidade e profundidade. Já possui métodos prontos para trabalhar com:

• Rápida renderização (+5000 sprites em computadores modernos);
• Tilemaps;
• Sistema de partículas;
• Controle de volume, com teclas de atalho;
• Parallax scrolling (multi-direcional);
• Colisão de sprites;
• Renderização de textos;
• Renderização retro com opções de 2x pixels, 3x pixels, etc;
• Não precisa da IDE do Flash, trabalha melhor com ferramentas livres como FlashDevelop;
• Organização das classes por estados do jogo;
• Botões simples;
• Utilitários para loop de música e tocar som;
• Efeitos especiais simples.

Sugestões e Críticas

Ficamos no aguardo das suas sugestões e críticas a respeito do jogo.

Apoio Financeiro Fundação Araucária.

Quer usar ela? Claro que sim!
Vamos lá!

Navegador Chrome

1) Abra o navegador Chrome;
2) Clique com o botão direito da barra de endereço;
3) Selecione a opção “Edit Search Engines”;
4) Clique na linha “Google (Default)” e no botão “Edit”;
5) Mude o keyword de “google.com.br” para “google.com”;
6) Feche a tela;
7) Acesse http://www.google.com;
8) Cole na barra de endereço o seguinte código:

javascript:void(document.cookie="PREF=ID=20b6e4c2f44943bb:U=4bf292d46faad806:TM=1249677602:LM=1257919388:S=odm0Ys-53ZueXfZG;path=/; domain=.google.com");

9) Dê um refresh no navegador;
10) Pronto! Olha a nova interface do Google!

Navegador Firefox

No Firefox, é mais complicado.

1) Com o Firefox fechado.
2) Vá em C:\Arquivos de Programas\Mozilla Firefox\searchplugins e abra o arquivo google.xml;
3) Com o Bloco de Notas. Procure o texto:

<Param name="q" value="{searchTerms}"/>

4) e, depois dele, cole este texto:

<Param name="hl" value="en"/>

5) Salve e feche o arquivo;
6) Abra o Firefox;
7) Cole na barra de endereço o seguinte código:

javascript:void(document.cookie="PREF=ID=20b6e4c2f44943bb:U=4bf292d46faad806:TM=1249677602:LM=1257919388:S=odm0Ys-53ZueXfZG;path=/; domain=.google.com");

8) Dê um refresh no navegador;

Então vamos implementar isso no braço, talvez não seja a forma mais elegante do mundo, mas funciona.

No seu model:

class Ong < ActiveRecord::Base
  # Paperclip
  has_attached_file :logo, :styles => { :thumb => "100x100>" }
  validates_attachment_size :logo, :less_than => 50.kilobytes, :message => I18n.t('activerecord.errors.messages.attachment_size', :min => 0, :max => 50.kilobytes)
end

Agora você precisar criar a diretiva activerecord.errors.messages.attachment_size no seu config/locales/pt-BR.yml:

pt-BR:
  # Active Record
  activerecord:
    errors:
      template:
        header:
          one: "Não foi possível gravar: 1 erro"
          other: "Não foi possível gravar: {{count}} erros."
        body: "Por favor, verifique o(s) seguinte(s) campo(s):"
      messages:
        attachment_size: "tamanho do arquivo deve estar entre {{min}} e {{max}} bytes"

Pronto! Seja feliz!
Se o plugin não faz, a gente faz.

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

Eu estou usando o Date Picker do jQuery em um campo do tipo text_field.

Vou mostrar um esboço de como eu fiz isso, em primeiro lugar eu defini no arquivo config/environment.rb o idioma:

config.i18n.default_locale = 'pt-BR'

Depois eu defini no arquivo config/locales/pt-BR.yml os formatos de data:

pt-BR:
  date:
    formats:
      default: "%d/%m/%Y"
      short: "%d de %B"
      long: "%d de %B de %Y"
 
    day_names: [Domingo, Segunda, Terça, Quarta, Quinta, Sexta, Sábado]
    abbr_day_names: [Dom, Seg, Ter, Qua, Qui, Sex, Sáb]
    month_names: [~, Janeiro, Fevereiro, Março, Abril, Maio, Junho, Julho, Agosto, Setembro, Outubro, Novembro, Dezembro]
    abbr_month_names: [~, Jan, Fev, Mar, Abr, Mai, Jun, Jul, Ago, Set, Out, Nov, Dez]
    order: [ :day, :month, :year ]

No meu formulário eu deixei assim:

<% content_for :javascripts do %>
  <%= include_jquery %>
  <%= javascript_include_tag "jquery.maskedinput-1.2.2.min" %>
  <% javascript_tag do %>
    $(document).ready(function() {
      // Adiciona date picker ao campo data de nascimento
      $.datepicker.setDefaults($.extend({showMonthAfterYear: false}, $.datepicker.regional['<%= I18n.locale %>']));
      $("#investor_date_of_birth").datepicker({
        showOn: 'both',
        buttonImage: '/images/calendar.gif',
        buttonImageOnly: false,
        buttonText: '<%= t('ui.admin.crud.datepicker_button_text') %>',
        changeMonth: true,
        changeYear: true,
        yearRange: '1900:<%= Time.now.year %>'
      });
 
      // Adiciona mascara ao campo data de nascimento
      $("#investor_date_of_birth").mask("99/99/9999");
    });
  <% end %>
<% end %>
 
<% form_for [:admin, @investor] do |f| -%>
  <%= f.error_messages %>
 
  <%= f.label :date_of_birth %>
 
  <% if @investor.new_record? %>
    <%= f.text_field :date_of_birth, :class => "smallInput" %>
  <% else %>
    <%= f.text_field :date_of_birth, :value => l(@investor.date_of_birth, :format => :default), :class => "smallInput" %>
  <% end %>
<% end %>

Caso exista o registro é realizado a conversão para exibir a data corretamente no formulário, não é necessário fazer conversão para salvar no banco de dados, o Rails já faz isso automaticamente.

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

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.

Isso também é útil quando você quer delimitar uma faixa de valores válidos para o campo.

Geralmente os campos de chave estrangeira são do tipo integer que pertence ao intervalo de -2147483648 até +2147483647, onde a grande maioria das aplicações trabalha somente com o conjunto dos números N* (naturais sem o zero).

Eu recomendo a seguinte validação no seu model:

class Investor < ActiveRecord::Base
  # Para chaves estrangeiras
  validates_numericality_of [:country_id, :gender_id, :civil_position_id], :greater_than_or_equal_to => 1, :less_than_or_equal_to => 2147483647
  # Para faixa de valor definida
  validates_numericality_of :number_of_dependents, :allow_nil => true, :greater_than_or_equal_to => 0, :less_than_or_equal_to => 9999
end

Desta forma para chaves estrangeiras são apenas aceitos valores de 1 até 2147483647.

Já para a faixa de valor definida você mesmo deve definir, conforme a sua necessidade, no caso do exemplo acima de 0 até 9999.

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