Módulo: Mongoid::Fields::ClassMethods

Definido em:
lib/mongoid/fields.rb,
lib/mongoid/fields.rb

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#variable_names ➤ Array<String>

Retorna uma array de nomes para os atributos disponíveis neste objeto.

Fornece os nomes dos campo de forma independente de ORM. Rails v3.1+ usa esse método para envolver automaticamente os parâmetros em solicitações JSON.

Exemplos:

Obtenha os nomes dos campos

Model.attribute_names

Retorna:

  • (Array<String>) —

    Os nomes dos campo



449
450
451
 
# Arquivo 'lib/mongoid/fields.rb', linha 449

def Atributo_nomes
  Campos.keys
end

#auto_embed_field(name, model: 'voyage-4', num_dimensions: nil, quantization: nil, similarity: nil, index: nil) ⇒ Object

Declara um campo de texto e registra um índice do Atlas Vector Search correspondente para ele usando o tipo auto-embedding (autoEmbed). O Atlas gera as incorporações automaticamente no momento do índice e da consulta; nenhum vetor pré-computado é necessário.

Exemplos:

Declaração mínima.

class Article
  include Mongoid::Document
  auto_embed_field :description
end

Com todas as opções.

class Article
  include Mongoid::Document
  auto_embed_field :description,
                   model: 'voyage-4',
                   num_dimensions: 512,
                   quantization: 'binary',
                   similarity: 'cosine',
                   index: :article_embed
end

Parâmetros:

  • name (Símbolo | string) —

    O nome do campo de texto a ser declarado e incorporado automaticamente.

  • Modelo (string) (padrão para: 'voyage-4') —

    O nome do embedding model. O padrão é "voyage-4" (recomendado). Valores suportados na pré-visualização pública: Voyage-4-large, Voyage-4, Voyage-4-lite, Voyage-code-3.

  • num_dimensions (Inteiro | nulo) (padrão para: nil) —

    Número de dimensions vetoriais. Valores suportados: 256, 512, 1024, 2048. Padrão: 1024.

  • quantização (string | nil) (padrão para: nil) —

    Tipo de quantization: float, scalar, binary ou binaryNoRescore. Padrão: escalar.

  • similaridade (string | nil) (padrão para: nil) —

    Função de similaridade: dotProduct, cosine ou euclidean.

  • index (Símbolo | String | nil) (padrão para: nil) —

    O nome do índice. Se omitido, o índice não é nomeado e o Atlas o chama de "padrão".



542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
 
# Arquivo 'lib/mongoid/fields.rb', linha 542

def auto_embed_field(name, modelo: 'voyage-4', num_dimensions: nada, quantization: nada, similaridade: nada, Índice: nada)
  Campo(name, tipo: String)

  field_spec = {
    tipo: 'autoEmbed',
    Modalidade: 'text',
    caminho: name.to_s,
    modelo: Modelo
  }
  field_spec[numDimensions] = num_dimensions se num_dimensions
  field_spec[quantization]  = quantização  se quantização
  field_spec[: similarity]    = similaridade    se similaridade

  se index
    vector_search_index(index, campos: [ field_spec ])
  mais
    vector_search_index(campos: [ field_spec ])
  end
end

#clean_localized_field_names(name) ⇒ Field

Remove _translations do nome de campo fornecido. Isso é feito somente quando ainda não existe um nome de campo ou relação com o mesmo nome (ou seja, com o sufixo _translations). Esta verificação para um campo existente é feita recursivamente

Parâmetros:

  • name (string | Símbolo) —

    O nome do campo a ser limpo.

Retorna:

  • (Campo) —

    O nome do campo sem _translations



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# Arquivo 'lib/mongoid/fields.rb', linha 98

def Clean_localized_field_names(name)
  name = database_field_name(name.to_s)

  classe = auto
  [].toque fazer |res|
    ar = name.dividir('.')
    ar.cada_com_index fazer |fn, i|
      chave = fn
      a menos que classe.Campos.chave?(fn) || classe.relações.chave?(fn)
        chave = se fn.end_with?(Translations_SFX)
                fn.delete_suffix(Translations_SFX)
              mais
                fn
              end

      end
      res.push(chave)

      se classe.Campos.chave?(fn)
        res.push(ar.derrubar(i + 1).juntar('.')) a menos que i == ar.Tamanho - 1
        intervalo
      elsif classe.relações.chave?(fn)
        classe = classe.relações[chave].classe
      end
    end
  end.juntar('.')
end

#database_field_name(name) ➤ string

Obtenha o nome do campo fornecido conforme armazenado no banco de dados. Usado para determinar se o campo tem um nome alternativo ou não.

Parâmetros:

  • name (string | Símbolo) —

    O nome a ser obtido.

Retorna:

  • (string) —

    O nome do campo conforme armazenado no banco de dados.



459
460
461
 
# Arquivo 'lib/mongoid/fields.rb', linha 459

def database_field_name(name)
  Campos.database_field_name(name, relações, aliased_fields, aliased_associations)
end

#extract_id_field(attributes) ➤ Objeto

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.

Extrai o campo ID do hash de atributos especificados com base nos aliases definidos nesta classe.

Parâmetros:

  • attributes (Hash) —

    Os atributos a serem inspecionados.

Retorna:

  • (Objeto) —

    O valor do ID .



81
82
83
84
85
86
87
88
 
# Arquivo 'lib/mongoid/fields.rb', linha 81

def extract_id_field(attributes)
  id_fields.cada fazer |k|
    se v = attributes[k]
      Método v
    end
  end
  nada
end

#campo(name, options = {}) ⇒ Field

Define todos os campos acessíveis no documento Para cada campo definido, um getter e setter serão adicionados como um método de instância ao documento.

Exemplos:

Defina um campo.

field :score, type: Integer, default: 0

Parâmetros:

  • name (Símbolo) —

    O nome do campo.

  • opções (Hash) (padrão para: {}) —

    As opções a serem passadas para o campo .

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

  • :type (Classe | Símbolo | string) —

    O tipo do campo.

  • :label (string) —

    O rótulo do campo.

  • :default (Objeto | Proc) —

    O padrão do campo.

Retorna:

  • (Campo) —

    O campo gerado



577
578
579
580
581
582
583
584
585
 
# Arquivo 'lib/mongoid/fields.rb', linha 577

def Campo(name, opções = {})
  nomeado = name.to_s
  Validadores::macro.validar(auto, name, opções)
  adicionado = add_field(nomeado, opções)
  descendants.cada fazer |subclasse|
    subclasse.add_field(nomeado, opções)
  end
  adicionado
end

#id_fields ➤ Array<Símbolo | string>

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.

Retorna a lista de campos ID para esta classe de modelo , como strings e símbolos.

Retorna:

  • (Array<Símbolo | string>) —

    Lista de campos de ID.



62
63
64
65
66
67
68
69
70
71
 
# Arquivo 'lib/mongoid/fields.rb', linha 62

def id_fields
  IDS.dup.toque fazer |id_fields|
    aliased_fields.cada fazer |k, v|
      se v == '_id'
        id_fields << k.to_sym
        id_fields << k
      end
    end
  end
end

#replace_field(nome, tipo) ➤ Serializável

Substituir um campo por um novo tipo.

Exemplos:

Substitua o campo}.

Model.replace_field("_id", String)

Parâmetros:

  • name (string) —

    O nome do campo.

  • type (Classe) —

    O novo tipo de campo.

Retorna:



596
597
598
599
 
# Arquivo 'lib/mongoid/fields.rb', linha 596

def replace_field(name, type)
  remove_defaults(name)
  add_field(name, Campos[name].opções.mesclar(tipo: type))
end

#traverse_association_tree(key) {|O, O, Se| ... } ➤ Campo

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.

Percorra a árvore de associações e procure o campo para a chave fornecida.

Parâmetros:

  • chave (string) —

    A chave usada para pesquisar a árvore de associação.

  • &block —

    O bloco.

Parâmetros de rendimento:

  • O (Símbolo) —

    método atual.

  • O (Símbolo | string) —

    campo ou relação.

  • Se (verdadeiro | falso) —

    o segundo parâmetro de rendimento é um campo ou não.

Retorna:

  • (Campo) —

    O campo encontrado para a chave fornecida no final da pesquisa. Isso retornará nulo se a última coisa encontrada for uma associação ou nenhum campo for encontrado para a chave fornecida.



627
628
629
 
# Arquivo 'lib/mongoid/fields.rb', linha 627

def traverse_association_tree(chave, &noum: bloco ; verb: bloquear)
  Campos.traverse_association_tree(chave, Campos, relações, aliased_associations, &noum: bloco ; verb: bloquear)
end

#usando_object_ids? ➤ verdadeiro | false

Método de conveniência para determinar se estamos usando BSON::ObjectIds como nosso ID.

Exemplos:

Essa classe usa IDs de objeto ?

person.using_object_ids?

Retorna:

  • (verdadeiro | falso) —

    Se a classe usar BSON::ObjectIds para o ID.



608
609
610
 
# Arquivo 'lib/mongoid/fields.rb', linha 608

def usando_object_ids?
  Campos['_id'].object_id_field?
end

#vector_field(name, dimensions:, similarity: 'cosine', índice: nil) ⇒ objeto

Declara um campo de vector embeddings e registra um índice correspondente do Atlas Vector Search para ele em uma etapa.

O campo é armazenado como um array. Para opções avançadas de índice (quantization, método de indexação, ajuste HNSW), use a combinação explícita field + vector_search_index.

Exemplos:

Declaração mínima.

class Article
  include Mongoid::Document
  vector_field :embedding, dimensions: 1536
end

Com todas as opções.

class Article
  include Mongoid::Document
  vector_field :embedding, dimensions: 1536,
                           similarity: 'dotProduct',
                           index: :article_vectors
end

Parâmetros:

  • name (Símbolo | string) —

    O nome do campo de embedding.

  • Dimensões (Inteiro) —

    O número de vector dimensions. Obrigatório.

  • similaridade (string) (padrão para: 'cosine') —

    A métrica de similaridade a ser usada: 'cosine' (padrão), 'euclidean' ou 'dotProduct'.

  • index (Símbolo | String | nil) (padrão para: nil) —

    O nome do índice de pesquisa vetorial. Se omitido, o índice não é nomeado e o Atlas o chama de "padrão".



490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
 
# Arquivo 'lib/mongoid/fields.rb', linha 490

def vector_field(name, dimensions:, similaridade: 'cosine', Índice: nada)
  Campo(name, tipo: Array)

  field_spec = {
    tipo: 'vetor',
    caminho: name.to_s,
    numDimensions: Dimensões,
    similaridade: similaridade
  }

  se index
    vector_search_index(index, campos: [ field_spec ])
  mais
    vector_search_index(campos: [ field_spec ])
  end
end