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 escrevem 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:



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

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

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

  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? { |chave|
        key_s = chave.to_s
        key_s.start_with?('$') && !seletor[Campo].keys.map(&:to_s).incluir?(key_s)
      }
    então
      # 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 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:



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
134
135
136
137
138
139
140
141
142
143
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 108

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

  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
  mais
    # Outros operadores precisam ser adicionados separadamente
    se seletor[operador, operador]
      add_logical_operator_expression('$e', [operador, operador => op_expr])
    mais
      seletor.Armazenar(operador, operador, op_expr)
    end
  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:



223
224
225
226
227
228
229
230
231
232
233
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 223

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

  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 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:



188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# Arquivo 'lib/mongoid/criteria/queryable/storable.rb', linha 188

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

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

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

  # 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