Go to English Blog

Usando PostgreSQL e HStore no Rails 4

Leia em 5 minutos

O Rails 4 adicionou diversas novidades por todo o framework. Isso inclui uma integração muito melhor com o PostgreSQL, como suporte a novos tipos de campos.

Uma alteração particularmente interessante é o suporte ao campo hstore, que permite armazenar uma estrutura de dados chave-valor. Esta funcionalidade é extremamente útil como em casos onde as chaves armazenadas podem variar bastante nos registros, mas que precisam ser eventualmente utilizadas em queries.

O Rails possui suporte para armazenar dados serializados no banco de dados, mas isso possui uma desvantagem muito grande: não é possível fazer buscas em um determinado campo desse dado serializado. Isso não acontece no hstore, pois você pode fazer consultas diferentes, como registros que possuem uma determinada chave ou valor.

O hstore possui uma desvantagem: todos os valores são armazenados como strings. Isso significa que você terá que fazer a coerção dos valores manualmente se isso for importante para você.

Veja abaixo como usar o hstore, com algumas dicas de otimização de índices e coerção dos valores.

Atualizando o PostgreSQL

O PostgreSQL disponível no Ubuntu 12.04 LTS está na versão 9.1.9. Embora o suporte a hstore seja à partir da versão 9.0, a versão do Ubuntu não funciona muito bem com o Rails. Estranhamente, o método que ativa extensões no arquivo de migração não é persistido. Isso não acontece se você estiver rodando o PostgreSQL 9.2+.

Adicione a chave pública GPG.

wget -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

Depois, crie o arquivo com o endereço do repositório.

echo deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main | sudo tee /etc/apt/sources.list.d/postgresql.list

Se você instalou o PostgreSQL anteriormente, remova-o agora.

sudo apt-get remove postgresql-9.1 postgresql-contrib-9.1

Finalmente, atualize a lista de pacotes e instale o novo PostgreSQL.

sudo apt-get update
sudo apt-get install postgresql-9.3 postgresql-contrib-9.3

Crie o usuário que terá acesso ao banco de dados. No exemplo abaixo, mostro como fazer isso para o Vagrant.

sudo -u postgres psql -c "CREATE USER vagrant WITH SUPERUSER CREATEDB ENCRYPTED PASSWORD 'vagrant'"

Na versão disponível no repositório Debian do PostgreSQL, a porta usada é a 5433, diferente da versão do repositório do Ubuntu. Altere-a.

sudo sed -i "s/port = 5433/port = 5432/" /etc/postgresql/9.3/main/postgresql.conf

Se quiser alterar o binding do PostgreSQL para conectar através de uma interface gráfica, execute as linhas abaixo.

sudo tee -a /etc/postgresql/9.3/main/pg_hba.conf <<-TEXT
host all all 0.0.0.0/0 md5
TEXT

sudo sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '*'/" /etc/postgresql/9.3/main/postgresql.conf

Agora, reinicie o PostgreSQL.

sudo /etc/init.d/postgresql restart

Ativando a extensão de hstore

Você pode gerar uma migração para ativar esta extensão com o comando rails generate migration create_extension_hstore. Esta extensão precisa ser ativada para cada banco que você criar.

class CreateExtensionHstore < ActiveRecord::Migration
  def change
    enable_extension "hstore"
  end
end

NOTA: Após executar esta migração, verifique se esta chamada foi persistida no arquivo db/schema.rb. Se ela não estiver no arquivo, atualize seu PostgreSQL conforme a seção anterior.

Criando seu campo hstore

Definir um novo campo usando o tipo hstore é muito simples. Basta utilizar o método ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::ColumnMethods#hstore.

class AddPreferencesOnUsers < ActiveRecord::Migration
  def change
    add_column :users, :preferences, :hstore
  end
end

Se você vai fazer buscas nesse campo, é preciso definir o índice. Existem dois tipos de índices que podem ser usados: GiST e GIN.

Os índices GIN são três vezes mais rápidos para buscar, mas também demoram três vezes mais para serem indexados, além de ocuparem mais espaço. São melhores quando existem mais de 100 mil termos únicos.

Os índices GiST são mais lentos que GIN. Em compensação, são mais rápidos para serem indexados. Funcionam melhor quando existem menos de 100 mil termos únicos.

Para criar o índice, utilize a opção :using.

class AddPreferencesIndexOnUsers < ActiveRecord::Migration
  def change
    add_index :orders, :payment_details, using: :gin
  end
end

Agora basta identificar o tipo do campo no modelo.

class User < ActiveRecord::Base
  store_accessor :preferences
end

Uma vez que seu modelo está configurado, você pode armazenar dados do tipo Hash.

user = User.new
user.preferences = {
  github: "fnando",
  twitter: "fnando"
}

user.save!
user.reload

user.preferences[:twitter]
#=> fnando

Uma das desvantagens de usar o campo hstore é que ele armazena apenas strings. Qualquer tipo diferente de String será convertido na hora que o dado for armazenado.

user.preferences[:newsletter] = false
user.save!
user.reload

user.preferences[:newsletter].class
#=> String

Isso pode ser um problema, mas existe uma maneira simples de resolver. E para isso iremos usar a biblioteca Virtus.

Usando o Virtus

Virtus é uma biblioteca que permite definir atributos e especificar o tipo desses atributos. Primeiro vamos criar uma classe chamada UserPreferences.

class UserPreferences
  include Virtus.model

  attribute :github, String
  attribute :twitter, String
  attribute :newsletter, Boolean
end

Uma das vantagens do Virtus é que ele faz todo o trabalho “sujo”, incluindo implementar o método UserPreferences#initialize de modo que ele faça o mass-assignment. E durante esse processo de inicialização ele também faz a coerção dos tipos.

preferences = UserPreferences.new(user.preferences)

preferences.newsletter.class
#=> FalseClass

A única coisa chata é que você precisa instanciar a classe UserPreferences sempre que quiser acessar os dados. A não ser que exista alguma maneira…

…e existe! Em vez de usar o método ActiveRecord::Base.store_accessor, podemos definir um serializer personalizado que faz todo o processo de serialização. Altere a classe User para usar a classe UserPreferences como serializer.

class User < ActiveRecord::Base
  serialize :preferences, UserPreferences
end

O Rails exige que o serializer implemente apenas os métodos dump e load. O método dump será chamado sempre que o objeto precisar ser persistido no banco de dados. No nosso caso, iremos retornar um Hash. Já o método load receberá o Hash retornado pelo campo hstore.

class UserPreferences
  include Virtus.model

  attribute :github, String
  attribute :twitter, String
  attribute :newsletter, Boolean

  def self.dump(preferences)
    preferences.to_hash
  end

  def self.load(preferences)
    new(preferences)
  end
end

Agora, vamos ver se isso funciona!

user = User.first

user.preferences.class
#=> UserPreferences

user.preferences.newsletter = true
user.save!
user.reload

user.preferences.newsletter.class
#=> TrueClass

Você deve estar perguntando porque não fazer a serialização como JSON ou algo do tipo. A grande vantagem de usar o campo hstore é que você pode consultar os valores armazenados.

Realizando consultas no campo hstore

Para encontrar todos os usuários que possuem a chave github:

User.where("preferences ? :key", key: "github")

Para encontrar todos os usuários que não possuem a chave github:

User.where("not preferences ? :key", key: "github")

Para encontrar o usuário que possui o perfil fnando no Github:

User.where("preferences @> hstore(:key, :value)",
  key: "github", value: "fnando"
).first

Para encontrar os usuários cujo perfil do Twitter possuam a substring nan:

User.where("preferences -> :key LIKE :value",
  key: "twitter", value: "%nan%"
)

Note que apenas os operadores @>, ?, ?& e ?| irão utilizar o índice que você criou. Por isso, evite fazer consultas como a que mostrei no último exemplo, já que isso pode ser muito lento dependendo de quantos registros você tiver.

Existem muitos outros operadores disponíveis. Para ver uma lista completa, acesse a documentação.

Finalizando

O hstore substituiu quase todos os usos que eu tinha para MongoDB, sem perder o poder do banco de dados relacional. Se você tem dúvidas sobre a performance do MongoDB vs PostgreSQL, não deixe de ver esse slidedeck (sim, benchmarks não servem de muita coisa, mas ainda assim vale dar uma lida).

Compartilhe: