Módulo: Mongoid::Criteria::Queryable::Storable Private

Incluído em:
Mongoid::Criteria::Queryable
Definido em:
lib/mongoid/criteria/queryable/storable.rb

Visão geral

Este módulo faz parte de uma API privada. Você deve evitar usar este módulo, se possível, pois ele pode ser removido ou alterado no futuro.

Este módulo encapsula métodos que gravam expressões de query no seletor de Critérios.

As expressões de query já devem ter sido expandidas conforme necessário. Os métodos deste módulo não executam processamento em valores de expressão.

Os métodos neste módulo não lidam com negação - se a negação for necessária, ela já deve ter sido tratada a montante desses métodos.

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#add_field_expression(campo, valor) ➤ Armazenável

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adiciona uma expressão de campo à query.

field deve ser um nome de campo e deve ser uma string. O código upstream deve ter convertido outros tipos de campo/chave para o formulário de string simples no momento em que este método é invocado.

value pode ser de qualquer tipo, ele é gravado no seletor inalterado.

Este método não realiza processamento no valor de campo fornecido.

Muta o receptor.

Parâmetros:

  • Campo (string) —

    O nome do campo .

  • valor (Objeto) —

    O valor do campo .

Retorna:

Aumenta:

  • (ArgumentError) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 34

def add_field_expression(Campo, valor)
  aumentar ArgumentError, "O campo deve ser uma string: #{field}" a menos que Campo.is_a?(String)

  aumentar ArgumentError, "O campo não pode ser um operador (ou seja, começar com $): #{field}" se Campo.start_with?('$')

  se seletor[Campo]
    # Já temos uma restrição pelo campo que estamos tentando
    # para restringir, combine as restrições.
    se valor.is_a?(Hash) && seletor[Campo].is_a?(Hash) &&
       valor.keys.todos? fazer |chave|
         key_s = chave.to_s
         key_s.start_with?('$') && !seletor[Campo].keys.map(&:to_s).incluir?(key_s)
       end
      # Vários operadores podem ser combinados no mesmo campo por
      # adicionando-os ao hash existente.
      new_value = seletor[Campo].mesclar(valor)
      seletor.Armazenar(Campo, new_value)
    elsif seletor[Campo] != valor
      add_operator_expression('$e', [ { Campo => valor } ])
    end
  mais
    seletor.Armazenar(Campo, valor)
  end

  auto
end

#add_logical_operator_expression(operator, op_expr ) ➤ Armazenável

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adiciona uma expressão de operador lógico ao seletor.

Este método lida apenas com operadores lógicos ($and, $nor e $or). Gera ArgumentError se chamado com outro operador. Observe que, em MQL, $not é um operador de nível de campo e não de nível de query e, portanto, $not não é tratado por esse método.

Este método usa o operador e a expressão de valor do operador separadamente para conveniência dos chamadores. Pode ser considerado lidar com o armazenamento do hash {operator => op_expr}.

Se o seletor consistir em uma única condição que é o operador especificado (no nível superior), a nova condição fornecida em op_expr será adicionada às condições existentes para o operador especificado. Por exemplo, se o seletor estiver atualmente:

{'$or' => [{'hello' => 'world'}]}

... e o operador for '$or' e op_expr for [{'test' => 123'}], o seletor resultante será:

{'$or' => [{'hello' => 'world'}, {'test' => 123}]}

Este método sempre adiciona as novas condições como requisitos adicionais; em outras palavras, ele não implementa o comportamento ActiveRecord ou/nor em que o receptor se torna um dos operandos. Espera-se que o código upstream deste método implemente tal comportamento.

Este método não simplifica valores (ou seja, se o seletor estiver atualmente vazio e o operador for $and, op_expr será gravado no seletor com $and mesmo que $and possa, em princípio, ser omitido). Também é esperado que tal simplificação já tenha sido realizada pelo código upstream.

Este método muta o receptor.

Parâmetros:

  • operador, operador (string) —

    O operador a adicionar.

  • op_expr (Array<Hash>) —

    Valor do operador a ser adicionado.

Retorna:

Aumenta:

  • (ArgumentError) 


101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 101

def add_logical_operator_expression(operador, operador, op_expr)
  aumentar ArgumentError, "O operador deve ser uma string: #{operator}" a menos que operador, operador.is_a?(String)

  a menos que %w[$and $nor $ ou].incluir?(operador, operador)
    aumentar ArgumentError,
          "Este método lida apenas com operadores lógicos ($and, $nor, $or). Operador dado: #{operator}"
  end

  a menos que op_expr.is_a?(Array)
    aumentar Errors::Query inválida, "#{operador} argumento deve ser uma array: #{Errors::InvalidQuery.truncate_expr(op_expr)}"
  end

  se seletor.Tamanho == 1 && seletor.keys.primeiro == operador, operador
    new_value = seletor.values.primeiro + op_expr
    seletor.Armazenar(operador, operador, new_value)
  elsif operador, operador == '$e' || seletor.vazio?
    # $and sempre pode ser adicionado ao nível superior e será combinado
    # com quaisquer outras condições existentes.
    se current_value = seletor[operador, operador]
      new_value = current_value + op_expr
      seletor.Armazenar(operador, operador, new_value)
    mais
      seletor.Armazenar(operador, operador, op_expr)
    end
  elsif seletor[operador, operador]
    # Outros operadores precisam ser adicionados separadamente
    add_logical_operator_expression('$e', [ { operador, operador => op_expr } ])
  mais
    seletor.Armazenar(operador, operador, op_expr)
  end

  auto
end

#add_one_expression(campo, value) ➤ Armazenável

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adiciona uma expressão arbitrária à query.

O campo pode ser um nome de campo ou um operador.

Muta o receptor.

Parâmetros:

  • Campo (string) —

    Nome do campo ou nome do operador.

  • valor (Objeto) —

    Valor do campo ou expressão do operador .

Retorna:

Aumenta:

  • (ArgumentError) 


207
208
209
210
211
212
213
214
215
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 207

def add_one_expression(Campo, valor)
  aumentar ArgumentError, "O campo deve ser uma string: #{field}" a menos que Campo.is_a?(String)

  se Campo.start_with?('$')
    add_operator_expression(Campo, valor)
  mais
    add_field_expression(Campo, valor)
  end
end

#add_operator_expression(operator, op_expr ) ➤ Armazenável

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Adiciona uma expressão de operador ao seletor.

Este método usa o operador e a expressão de valor do operador separadamente para conveniência dos chamadores. Pode ser considerado lidar com o armazenamento do hash {operator => op_expr}.

O valor do operador pode ser de qualquer tipo.

Se o seletor já tiver o operador especificado nele (no nível superior), a nova condição fornecida em op_expr será adicionada às condições existentes para o operador especificado. Isso é simples para $and; para outros operadores lógicos, o comportamento deste método é adicionar as novas condições ao operador existente. Por exemplo, se o seletor estiver atualmente:

{'foo' => 'bar', '$or' => [{'hello' => 'world'}]}

... e o operador for '$or' e op_expr for {'test' => 123'}, o seletor resultante será:

{'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}

Isso não implementa um OR entre o seletor existente e a nova expressão do operador - lidar com isso é tarefa dos métodos upstream. Esse método simplesmente armazena op_expr no seletor com base no pressuposto de que o seletor existente já é o lado esquerdo correto da operação.

Para operadores de nível de query não lógicos como $where e $text, se já houver um operador de nível superior com o mesmo nome, o op_expr é adicionado ao seletor por meio de um operador de nível superior $and, produzindo assim um seletor com ambos os valores do operador.

Este método não simplifica valores (ou seja, se o seletor estiver atualmente vazio e o operador for $and, op_expr será gravado no seletor com $and mesmo que $and possa, em princípio, ser omitido).

Este método muta o receptor.

Parâmetros:

  • operador, operador (string) —

    O operador a adicionar.

  • op_expr (Objeto) —

    Valor do operador a ser adicionado.

Retorna:

Aumenta:

  • (ArgumentError) 


178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 178

def add_operator_expression(operador, operador, op_expr)
  aumentar ArgumentError, "O operador deve ser uma string: #{operator}" a menos que operador, operador.is_a?(String)

  aumentar ArgumentError, "O operador deve começar com $: #{operator}" a menos que operador, operador.start_with?('$')

  Método add_logical_operator_expression(operador, operador, op_expr) se %w[$and $nor $ ou].incluir?(operador, operador)

  # Para outros operadores, se o operador já existir no
  # query, adicione a nova condição com $and, caso contrário, adicione o
  # nova condição para o nível superior.
  se seletor[operador, operador]
    add_logical_operator_expression('$e', [ { operador, operador => op_expr } ])
  mais
    seletor.Armazenar(operador, operador, op_expr)
  end

  auto
end