Tipos de campo

Campos não digitados

Se você não especificar um tipo para um campo, o Mongoid interpretará como o tipo Object padrão. Um campo não especificado pode armazenar valores de qualquer tipo que seja diretamente serializável para BSON. Você pode deixar um campo sem tipo se o campo puder conter tipos diferentes de dados ou se o tipo do valor do campo não for conhecido.

O exemplo seguinte define uma classe Product com um campo não digitado:

class Product
  include Mongoid::Document
  field :name, type: String
  field :properties
end

O tipo do campo properties é Object, mas varia dependendo do tipo de dados armazenados nesse campo. O exemplo seguinte salva dados no campo properties de duas maneiras diferentes:

product = Product.new(properties: "color=white,size=large")
# properties field saved as String: "color=white,size=large"
product = Product.new(properties: {color: "white", size: "large"})
# properties field saved as Object: {:color=>"white", :size=>"large"}

Como o Mongoid não realiza nenhuma conversão de tipo em campos não digitados ao ler do banco de dados, os valores que exigem manuseio especial podem não ser recuperados corretamente como o valor de um campo não digitado. Não armazene os seguintes tipos de dados BSON em campos não digitados:

• Date: retorna como Time em campos não digitados

• DateTime: retorna como Time em campos não digitados

• Range: retorna como Hash em campos não digitados

Hash

Você pode armazenar dados Hash em um campo utilizando o tipo Hash. Ao especificar um campo Hash como, certifique-se de seguir as Restrições de Nomenclatura do MongoDB para garantir que os valores sejam armazenados corretamente no banco de dados.

O exemplo seguinte cria uma classe Person e especifica o campo url como um Hash.

class Person
  include Mongoid::Document
  field :first_name
  field :url, type: Hash
end
person = Person.new(url: {'home_page' => 'http://www.homepage.com'})

Hora

Você pode armazenar valores como instâncias BSON Time utilizando o valor de campo Time. Time campos são armazenados no zona horário configurado para seu aplicação. Para saber mais sobre como configurar fusos horários, consulte a seção Configuração do fuso horário do guia Configuração do aplicativo.

O exemplo seguinte cria uma classe Voter e especifica que o valor do campo registered_at é um tipo Time:

class Voter
  include Mongoid::Document
  
  field :registered_at, type: Time
end
  
Voter.new(registered_at: Date.today)

Data

Você pode armazenar os seguintes tipos de valor em um campo especificado como Date:

• Date: Armazena o valor conforme fornecido.

• Time: armazena a parte de data do valor no zona horário do valor.

• DateTime: armazena a parte de data do valor no zona horário do valor.

• ActiveSupport::TimeWithZone: armazena a parte de data do valor no zona horário do valor.

• String: armazena a data especificada na string.

• Integer: pega o valor como se fosse um carimbo de data/hora UTC e o converte no zona horário configurado do seu aplicativo . O Mongoid então armazena a data retirada desse carimbo de data/hora.

• Float: pega o valor como se fosse um carimbo de data/hora UTC e o converte no zona horário configurado do seu aplicativo . O Mongoid então armazena a data retirada desse carimbo de data/hora.

Como a conversão de Time ou DateTime descarta a parte de tempo, recomendamos converter explicitamente os objetos String, Time e DateTime em Date antes de atribuí-los ao campo.

DateTime

Quando você atribui um valor a um campo definido como DateTime ou faz uma query nesses campos, o Mongoid converte o valor em um valor UTC Time antes de enviá-lo ao servidor MongoDB . O Mongoid salva o valor com o zona horário incorporado no objeto DateTime . Quando você recupera o valor, o Mongoid converte a hora UTC para o zona horário configurado para seu aplicação.

O exemplo seguinte cria uma classe Ticket e especifica o campo purchased_at como um campo DateTime :

class Ticket
  include Mongoid::Document
  field :purchased_at, type: DateTime
end

Se você salvar um valor inteiro ou flutuante em um campo DateTime, o valor será tratado como um carimbo de data/hora Unix em UTC. O exemplo seguinte salva um valor inteiro no campo purchased_at :

ticket.purchased_at = 1544803974
ticket.purchased_at
# Outputs: Fri, 14 Dec 2018 16:12:54 +0000

Se você salvar um valor de string em um campo DateTime, o Mongoid salvará o ticket com o zona horário especificado. Se um zona horário não for especificado, o Mongoid salvará o valor usando o fuso horário configurado como padrão para seu aplicação:

ticket.purchased_at = 'Mar 4, 2018 10:00:00 +01:00'
ticket.purchased_at
# Outputs: Sun, 04 Mar 2018 09:00:00 +0000

Para saber mais sobre como configurar fusos horários, consulte a seção Configuração do fuso horário do guia Configuração do aplicativo.

Carimbos de data e hora

Você pode incluir campos de carimbo de data/hora em uma classe incluindo o módulo Mongoid::Timestamps ao criar sua classe. Quando você inclui o Mongoid::Timestamps, o Mongoid cria os seguintes campos na sua classe:

• created_at: armazena a hora em que o documento foi criado.

• updated_at: armazena a hora em que o documento foi atualizado pela última vez.

O exemplo a seguir cria uma classe Post com campos de carimbo de data/hora:

class Post
  include Mongoid::Document
  include Mongoid::Timestamps
end

Você também pode optar por incluir somente os campos created_at ou updated_at, incluindo somente os módulos Created ou Updated. O exemplo a seguir cria uma classe Post somente com o campo created_at e uma classe Post somente com o campo updated_at:

class Post
  include Mongoid::Document
  include Mongoid::Timestamps::Created
end
class Post
  include Mongoid::Document
  include Mongoid::Timestamps::Updated
end

Você pode reduzir os nomes dos campo do registro de data e hora para c_at e u_at definindo a opção ::Short ao incluir o módulo:

class Post
  include Mongoid::Document
  include Mongoid::Timestamps::Short # For c_at and u_at.
end
class Post
  include Mongoid::Document
  include Mongoid::Timestamps::Created::Short # For c_at only.
end
class Post
  include Mongoid::Document
  include Mongoid::Timestamps::Updated::Short # For u_at only.
end

Você pode desativar a criação do campo de carimbo de data/hora para operações específicas chamando o método timeless na chamada de método. O exemplo a seguir desabilita os registros de data e hora para a operação save:

post.timeless.save

regexp

Você pode armazenar expressões regulares em um campo utilizando o tipo Regexp.

Enquanto o MongoDB implementa Expressões regulares compatíveis com Perl (PCRE), o Mongoid usa a biblioteca Onigmo do Ruby. PCRE e Onigmo fornecem funcionalidade geralmente semelhante, mas existem várias diferenças de sintaxe . Por exemplo, Onigmo utiliza \A e \z para corresponder ao início e fim de uma string, enquanto PCRE utiliza ^ e $.

Quando você declara um campo como Regexp, o Mongoid converte expressões regulares Ruby em expressões regulares BSON ao armazenar o resultado em seu banco de dados. O banco de dados retorna o campo como uma instância Bson::Regexp::Raw. Você pode usar o método compile em instâncias do BSON::Regexp::Raw para converter os dados de volta para uma expressão regular Ruby.

O exemplo seguinte cria uma classe Token e especifica o campo pattern como um Regexp:

class Token
  include Mongoid::Document
  
  field :pattern, type: Regexp
end
  
token = Token.create!(pattern: /hello.world/m)
token.pattern
# Outputs: /hello.world/m
# Reload the token from the database
token.reload
token.pattern
# Outputs: #<BSON::Regexp::Raw:0x0000555f505e4a20 @pattern="hello.world", @options="ms">

BigDecimal

Você pode usar o tipo BigDecimal para armazenar números com maior precisão. O Mongoid armazena valores BigDecimal de duas maneiras diferentes, dependendo do valor que você definiu para a propriedade de configuração Mongoid.map_big_decimal_to_decimal128 :

• Se definido como true, o Mongoid armazena BigDecimal valores como valores BSON Decimal128.

• Se definido como false (padrão), o Mongoid armazena BigDecimal valores como strings.

Considere as seguintes limitações ao configurar a opção Mongoid.map_big_decimal_to_decimal128 para true:

• Decimal128 tem alcance e precisão limitados. Decimal128 tem um valor máximo de aproximadamente 10^6145 e um mínimo de aproximadamente -10^6145, com um máximo de 34 bits de precisão. Se você estiver armazenando valores fora desses limites, recomendamos armazená-los como strings.

• Decimal128 aceita valores de NaN assinados, mas BigDecimal não. Recuperar valores de NaN Decimal128 assinados a partir do banco de dados como BigDecimal retorna o valor não assinado.

• Decimal128 mantém os zeros finais, mas BigDecimal não. Por esse motivo, recuperar valores Decimal128 do banco de dados como BigDecimal pode resultar em uma perda de precisão.

StringifiedSymbol

Use o tipo de campo StringifiedSymbol para armazenar valores que devem ser expostos como símbolos para aplicativos Ruby. StringifiedSymbol permite que você use símbolos enquanto garante a interoperabilidade com outros drivers. Esse tipo armazena todos os dados no banco de dados como strings e converte as strings em símbolos quando lidas pelo aplicação. Os valores que não podem ser convertidos diretamente em símbolos, como números inteiros e arrays, são convertidos em strings e, em seguida, em símbolos.

O exemplo seguinte define o campo status como StringifiedSymbol e demonstra como o campo é armazenado e retornado:

class Post
  include Mongoid::Document
  
  field :status, type: StringifiedSymbol
end
  
# Save status as a symbol
post = Post.new(status: :hello)
# status is stored as "hello" on the database, but returned as a Symbol
post.status
# Outputs: :hello
# Save status as a string
post = Post.new(status: "hello")
# status is stored as "hello" in the database, but returned as a Symbol
post.status
# Outputs: :hello

Tipos de campo personalizado fantasma

Você pode criar um tipo de campo personalizado que salva um valor diferente no banco de dados do valor atribuído no aplicação. Isso pode ser útil para ter valores descritivos no aplicação e, ao mesmo tempo, armazenar valores mais compactos no banco de dados.

O exemplo seguinte cria um tipo de ColorMapping que utiliza o nome da cor no aplicação, mas armazena a cor como um número inteiro no banco de dados:

class ColorMapping
  MAPPING = {
    'black' => 0,
    'white' => 1,
  }.freeze
  INVERSE_MAPPING = MAPPING.invert.freeze
  class << self
    def mongoize(object)
      MAPPING[object]
    end
    def demongoize(object)
      INVERSE_MAPPING[object]
    end
    def evolve(object)
      MAPPING.fetch(object, object)
    end
  end
end
class Profile
  include Mongoid::Document
  field :color, type: ColorMapping
end
profile = Profile.new(color: 'white')
profile.color
# Outputs: "white"
# Sets "color" field to 0 in MongoDB
profile.save!