Módulo: Mongoid::Persistable::Settable

Estendido por:
ActiveSupport::Concern
Incluído em:
Mongoid::Persistable
Definido em:
lib/mongoid/persistable/settable.rb

Visão geral

Define o comportamento das operações $set.

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#set(setters) ➤ Documento

Execute uma operação $set nos pares de campo/valor fornecidos e defina os valores no documento na memória.

A chave pode ser uma sequência pontilhada de chaves, caso em que o campo de nível superior é tratado como um hash aninhado e quaisquer chaves ausentes são criadas automaticamente:

Executar um conjunto aninhado como este mescla valores de chaves intermediárias:

Se o campo de nível superior não for um hash, seu valor original será descartado e o campo será substituído por um hash.

Observe que, diferentemente do $set do MongoDB, o conjunto do Mongoid escreve o campo inteiro mesmo ao definir um subconjunto do campo por meio da semântica de hash aninhado. Isso significa que executar um $set com semântica de hash aninhada pode substituir outras chaves de hash no campo de nível superior do banco de dados de dados.

Exemplos:

Defina os valores.

document.set(title: "sir", dob: Date.new(1970, 1, 1))

Defina os valores usando semântica de hash aninhado.

document.set('author.title' => 'Sir')
# => document.author == {'title' => 'Sir'}

Mesclagem de valor de hash aninhado.

document.set('author.title' => 'Sir')
document.set('author.name' => 'Linus Torvalds')
# => document.author == {'title' => 'Sir', 'name' => 'Linus Torvalds'}

Hash aninhado substituindo um valor não hash.

document.set('author' => 'John Doe')
document.set('author.title' => 'Sir')
# => document.author == {'title' => 'Sir'}

Parâmetros:

  • setters (Hash) —

    Os pares de campo/valor a serem definidos.

Retorna:



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# Arquivo 'lib/mongoid/persistable/settable.rb', linha 48

def set(setters)
  prepare_atomic_operation fazer |ops|
    process_atomic_operations(setters) fazer |Campo, valor|

      field_seq = Campo.to_s.dividir('.')
      Campo = field_seq.mudança
      se field_seq.Tamanho > 0
        # caminho de hash aninhado
        valor_antigo = attributes[Campo]

        # se o valor antigo não for um hash, substitua-o
        a menos que Hash === valor_antigo
          valor_antigo = {}
        end

        # desce ao hash, criando chaves intermediárias conforme necessário
        cur_value = valor_antigo
        enquanto field_seq.Tamanho > 1
          cur_key = field_seq.mudança
          # clobber em cada nível se o tipo não for um hash
          a menos que Hash === cur_value[cur_key]
            cur_value[cur_key] = {}
          end
          cur_value = cur_value[cur_key]
        end

        # agora que estamos no nível da folha, execute o conjunto
        # e substitua o que estava neste nível antes
        cur_value[field_seq.mudança] = valor

        # e defina o valor para o valor do campo de nível superior
        # porque é isso que passamos para $set
        valor = valor_antigo
      end

      process_attribute(Campo, valor)

      a menos que relações.incluir?(Campo.to_s)
        ops[atomic_attribute_name(Campo)] = attributes[Campo]
      end
    end
    { "$set" => ops } a menos que ops.vazio?
  end
end