Módulo: Mongo::QueryCache

Definido em:
build/ruby-driver-v2.19/lib/mongo/query_cache.rb

Definido sob namespace

Classes: Middleware

Recolhimento do Resumo do método de classe

Detalhes do método de classe

.cache ➤ Objeto

Execute o bloco enquanto usa o cache de query.

Exemplos:

Execute com o cache.

QueryCache.cache { collection.find }

Retorna:

  • (Objeto) —

    O resultado do bloqueio.



48
49
50
51
52
53
54
55
56
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 48

def cache
  habilitado = habilitado?
  auto.habilitado = true
  começar
    rendimento
  garantir
    auto.habilitado = habilitado
  end
end

.limpar ➤ nulo

Limpe o cache de query.

Exemplos:

Limpe o cache.

QueryCache.clear

Retorna:

  • (nil) —

    Sempre nulo.



90
91
92
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 90

def Limpar
  Thread.Current["[mongo]:query_cache"] = nada
end

.clear_namespace(namespace) ➤ nil

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.

Limpe a seção do cache da query armazenando cursores com resultados desse namespace.

Parâmetros:

  • namespace (string) —

    O namespace a ser limpo, no formato "banco de dados.collection".

Retorna:

  • (nil) —

    Sempre nulo.



103
104
105
106
107
108
109
110
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 103

def clear_namespace(namespace)
  cache_table.excluir(namespace)
  # A chave nil é onde os cursores são armazenados que podem potencialmente ler de
  # múltiplas coleções. Esta chave deve ser limpa em cada operação de gravação
  # para evitar o retorno de dados obsoletos.
  cache_table.excluir(nada)
  nada
end

.habilitado=(valor) ➤ Objeto

Defina se o cache está ativado.

Exemplos:

Defina se o cache está ativado.

QueryCache.enabled = true

Parâmetros:

  • valor (verdadeiro, falso) —

    O valor habilitado.



28
29
30
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 28

def habilitado=(valor)
  Thread.Current["[mongo]:query_cache:enabled"] = valor
end

.habilitado? ➤ true, false

O cache de query está habilitado no thread atual?

Exemplos:

O cache de query está habilitado?

QueryCache.enabled?

Retorna:

  • (verdadeiro, falso) —

    Se o cache estiver habilitado.



38
39
40
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 38

def habilitado?
  !!Thread.Current["[mongo]:query_cache:enabled"]
end

.get(**opts) ➤ Mongo::CashingCursor | nada

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.

Para as opções de query fornecidas, recupere um cursor em cache que possa ser usado para obter os resultados corretos da query, se houver um no cache.

Parâmetros:

  • opciona (Hash) —

    um conjunto personalizável de opções

Hash de opções (**opts):

  • :namespace (string | nil) —

    O namespace da consulta, no formato “database_name.collection_name”.

  • :selector (Array, Hash) —

    O seletor passado para a query. Para a maioria das queries, isso será um Hash, mas para aggregations, será uma array representando o pipeline de agregação . Pode não ser nulo.

  • :skip (Inteiro | nulo) —

    O valor de ignorar da query.

  • :sort (Hash | nulo) —

    A ordem dos resultados da query (por exemplo { nome: -1 }).

  • :limit (Inteiro | nulo) —

    O valor limite da query.

  • :projection (Hash | nulo) —

    A projeção dos resultados da query (por exemplo { nome: 1 }).

  • :collation (Hash | nulo) —

    O agrupamento da query (por exemplo { “locale" => "fr_CA" }).

  • :read_concern (Hash | nulo) —

    A preocupação de leitura da consulta (por exemplo { nível: :maioria }).

  • :read_preference (Hash | nulo) —

    A preferência de leitura da query (por exemplo { modo: :secundário }).

  • :multi_collection (Boolean | nil) —

    Se os resultados da query podem vir de várias collections. Quando verdadeiros, esses resultados serão armazenados sob a chave do namespace nil e apagados em cada comando de escrita.

Retorna:

  • (Mongo::CashingCursor | nil) —

    Retorna um CachedCursor se houver no cache de query, caso contrário, retorna nulo.



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 181

def obter(**opciona)
  limit = normalized_limit(opciona[:limit])

  _namespace_key = namespace_key(**opciona)
  _cache_key = cache_key(**opciona)

  namespace_hash = cache_table[_namespace_key]
  Método nada a menos que namespace_hash

  caching_cursor = namespace_hash[_cache_key]
  Método nada a menos que caching_cursor

  cache_cursor_limit = normalized_limit(caching_cursor.vista.limit)

  # Existem dois cenários em que um cursor de cache pode atender à
  # query:
  # 1. A query tem um limite e o cursor armazenado não tem limite ou
  # um limite maior.
  # 2. A consulta não tem limite e o cursor armazenado não tem limite.
  #
  # Caso contrário, retorne nulo porque o cursor armazenado não satisfazer
  # a query.

  se limit && (cache_cursor_limit.nada? || cache_cursor_limit >= limit)
    caching_cursor
  elsif limit.nada? && cache_cursor_limit.nada?
    caching_cursor
  mais
    nada
  end
end

.normalized_limit(limit) ➤ Objeto 



213
214
215
216
217
218
219
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 213

def normalized_limit(limit)
  Método nada a menos que limit
  # Para fins de cache, um limite de 0 significa que não há limite, pois o mongo o trata como tal.
  Método nada se limit == 0
  # Para fins de cache, um limite negativo é o mesmo que um limite positivo.
  limit.abs
end

.set(cursor, **opts) ➤ true

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.

Armazene uma instância CashingCursor no cache de query associado às opções de query especificadas.

Parâmetros:

  • cursor (Mongo::CashingCursor) —

    A instância CashingCursor a ser armazenada.

  • opciona (Hash) —

    um conjunto personalizável de opções

Hash de opções (**opts):

  • :namespace (string | nil) —

    O namespace da consulta, no formato “database_name.collection_name”.

  • :selector (Array, Hash) —

    O seletor passado para a query. Para a maioria das queries, isso será um Hash, mas para aggregations, será uma array representando o pipeline de agregação . Pode não ser nulo.

  • :skip (Inteiro | nulo) —

    O valor de ignorar da query.

  • :sort (Hash | nulo) —

    A ordem dos resultados da query (por exemplo { nome: -1 }).

  • :limit (Inteiro | nulo) —

    O valor limite da query.

  • :projection (Hash | nulo) —

    A projeção dos resultados da query (por exemplo { nome: 1 }).

  • :collation (Hash | nulo) —

    O agrupamento da query (por exemplo { “locale" => "fr_CA" }).

  • :read_concern (Hash | nulo) —

    A preocupação de leitura da consulta (por exemplo { nível: :maioria }).

  • :read_preference (Hash | nulo) —

    A preferência de leitura da query (por exemplo { modo: :secundário }).

  • :multi_collection (Boolean | nil) —

    Se os resultados da query podem vir de várias collections. Quando verdadeiros, esses resultados serão armazenados sob a chave do namespace nil e apagados em cada comando de escrita.

Retorna:

  • (verdadeiro) —

    Sempre verdadeiro.



142
143
144
145
146
147
148
149
150
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 142

def set(cursor, **opciona)
  _cache_key = cache_key(**opciona)
  _namespace_key = namespace_key(**opciona)

  cache_table[_namespace_key] ||= {}
  cache_table[_namespace_key][_cache_key] = cursor

  true
end

. objetosem cache

Execute o bloco com o cache de query desabilitado.

Exemplos:

Execute sem o cache.

QueryCache.uncached { collection.find }

Retorna:

  • (Objeto) —

    O resultado do bloqueio.



64
65
66
67
68
69
70
71
72
 
# File 'build/ruby-driver-v2.19/lib/mongo/query_cache.rb', linha 64

def uncached
  habilitado = habilitado?
  auto.habilitado = false
  começar
    rendimento
  garantir
    auto.habilitado = habilitado
  end
end