algoliasearch rails
3.0.1
Dokumentation • Community-Forum • Stapelüberlauf • Fehler melden • FAQ • Support
Mit diesem Juwel können Sie die Algolia Search API ganz einfach in Ihr bevorzugtes ORM integrieren. Es basiert auf dem Juwel algoliasearch-client-ruby. Rails 6.x und 7.x werden unterstützt.
Sie könnten an der Ruby on Rails-Beispielanwendung interessiert sein, die eine auf autocomplete.js basierende automatische Vervollständigung und eine auf InstantSearch.js basierende Seite mit sofortigen Suchergebnissen bereitstellt: algoliasearch-rails-example.
Die vollständige Referenz finden Sie auf der Website von Algolia.
Aufstellen
Verwendung
Optionen
objectIDIndizes
Testen
Fehlerbehebung
gem install algoliasearch-rails Fügen Sie den Edelstein zu Ihrer Gemfile hinzu:
gem "algoliasearch-rails"Und laufe:
bundle install Erstellen Sie eine neue Datei config/initializers/algoliasearch.rb um Ihre APPLICATION_ID und API_KEY einzurichten.
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' }Das Juwel ist mit ActiveRecord, Mongoid und Sequel kompatibel.
Sie können verschiedene Timeout-Schwellenwerte konfigurieren, indem Sie zum Zeitpunkt der Initialisierung die folgenden Optionen festlegen:
AlgoliaSearch . configuration = {
application_id : 'YourApplicationID' ,
api_key : 'YourAPIKey' ,
} Dieses Gem nutzt in großem Umfang die Rückrufe von Rails, um die Indizierungsaufgaben auszulösen. Wenn Sie Methoden verwenden, die die Rückrufe after_validation , before_save oder after_commit umgehen, werden Ihre Änderungen nicht indiziert. Beispiel: update_attribute führt keine Validierungsprüfungen durch. Um Validierungen beim Aktualisieren durchzuführen, verwenden Sie update_attributes .
Allen vom AlgoliaSearch Modul injizierten Methoden wird algolia_ vorangestellt und mit einem Alias auf die zugehörigen Kurznamen versehen, sofern diese nicht bereits definiert sind.
Contact . algolia_reindex! # <=> Contact.reindex!
Contact . algolia_search ( "jon doe" ) # <=> Contact.search("jon doe") Der folgende Code erstellt einen Contact und fügt Ihrem Contact Suchfunktionen hinzu:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attributes :first_name , :last_name , :email
end
end Sie können entweder die zu sendenden Attribute angeben (hier haben wir uns auf :first_name, :last_name, :email beschränkt) oder nicht (in diesem Fall werden alle Attribute gesendet).
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes will be sent
end
end Sie können auch die Methode add_attribute verwenden, um alle Modellattribute + zusätzliche zu senden:
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes + extra_attr will be sent
add_attribute :extra_attr
end
def extra_attr
"extra_val"
end
end Wir bieten viele Möglichkeiten zur Konfiguration Ihres Index, sodass Sie die allgemeine Indexrelevanz optimieren können. Die wichtigsten sind die durchsuchbaren Attribute und die Attribute, die die Beliebtheit von Datensätzen widerspiegeln.
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# list of attribute used to build an Algolia record
attributes :title , :subtitle , :description , :likes_count , :seller_name
# the `searchableAttributes` (formerly known as attributesToIndex) setting defines the attributes
# you want to search in: here `title`, `subtitle` & `description`.
# You need to list them by order of importance. `description` is tagged as
# `unordered` to avoid taking the position of a match into account in that attribute.
searchableAttributes [ 'title' , 'subtitle' , 'unordered(description)' ]
# the `customRanking` setting defines the ranking criteria use to compare two matching
# records in case their text-relevance is equal. It should reflect your record popularity.
customRanking [ 'desc(likes_count)' ]
end
end Um ein Modell zu indizieren, rufen Sie einfach reindex für die Klasse auf:
Product . reindexUm alle Ihre Modelle zu indizieren, können Sie Folgendes tun:
Rails . application . eager_load! # Ensure all models are loaded (required in development).
algolia_models = ActiveRecord :: Base . descendants . select { | model | model . respond_to? ( :reindex ) }
algolia_models . each ( & :reindex ) Herkömmliche Suchimplementierungen verfügen in der Regel über Suchlogik und -funktionalität im Backend. Dies machte Sinn, wenn das Sucherlebnis darin bestand, dass ein Benutzer eine Suchabfrage eingab, diese Suche ausführte und dann zu einer Suchergebnisseite weitergeleitet wurde.
Die Implementierung der Suche im Backend ist nicht mehr erforderlich. Tatsächlich ist es in den meisten Fällen aufgrund der zusätzlichen Netzwerk- und Verarbeitungslatenz schädlich für die Leistung. Wir empfehlen dringend die Verwendung unseres JavaScript-API-Clients, der alle Suchanfragen direkt über den Browser, das Mobilgerät oder den Client des Endbenutzers ausgibt. Dadurch wird die allgemeine Suchlatenz reduziert und gleichzeitig Ihre Server entlastet.
Der JS-API-Client ist Teil des Gems. Sie benötigen lediglich algolia/v3/algoliasearch.min irgendwo in Ihrem JavaScript-Manifest, zum Beispiel in application.js , wenn Sie Rails 3.1+ verwenden:
//= require algolia/v3/algoliasearch.minDann können Sie in Ihrem JavaScript-Code Folgendes tun:
var client = algoliasearch ( ApplicationID , Search - Only - API - Key ) ;
var index = client . initIndex ( 'YourIndexName' ) ;
index . search ( 'something' , { hitsPerPage : 10 , page : 0 } )
. then ( function searchDone ( content ) {
console . log ( content )
} )
. catch ( function searchFailure ( err ) {
console . error ( err ) ;
} ) ;Wir haben vor Kurzem (März 2015) eine neue Version (V3) unseres JavaScript-Clients veröffentlicht. Wenn Sie unsere vorherige Version (V2) verwendet haben, lesen Sie den Migrationsleitfaden
Hinweise: Wir empfehlen die Verwendung unseres JavaScript-API-Clients, um Abfragen direkt über den Endbenutzer-Browser durchzuführen, ohne den Umweg über Ihren Server.
Bei einer Suche werden ORM-konforme Objekte zurückgegeben, indem diese aus Ihrer Datenbank neu geladen werden. Wir empfehlen die Verwendung unseres JavaScript-API-Clients zur Durchführung von Abfragen, um die Gesamtlatenz zu verringern und Ihre Server zu entlasten.
hits = Contact . search ( "jon doe" )
p hits
p hits . raw_answer # to get the original JSON raw answer Jedem ORM-Objekt wird ein highlight_result Attribut hinzugefügt:
hits [ 0 ] . highlight_result [ 'first_name' ] [ 'value' ]Wenn Sie die rohe JSON-Antwort von der API abrufen möchten, ohne die Objekte erneut aus der Datenbank zu laden, können Sie Folgendes verwenden:
json_answer = Contact . raw_search ( "jon doe" )
p json_answer
p json_answer [ 'hits' ]
p json_answer [ 'facets' ] Suchparameter können entweder über die Indexeinstellungen statisch in Ihrem Modell oder dynamisch zum Suchzeitpunkt angegeben werden, indem Suchparameter als zweites Argument der search angegeben werden:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :first_name , :last_name , :email
# default search parameters stored in the index settings
minWordSizefor1Typo 4
minWordSizefor2Typos 8
hitsPerPage 42
end
end # dynamical search parameters
p Contact . raw_search ( 'jon doe' , { hitsPerPage : 5 , page : 2 } ) Auch wenn wir dringend empfehlen, alle Such- (und damit Paginierungs-)Vorgänge von Ihrem Frontend aus mit JavaScript durchzuführen , unterstützen wir sowohl will_paginate als auch kaminari als Paginierungs-Backend.
Um :will_paginate zu verwenden, geben Sie :pagination_backend wie folgt an:
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' , pagination_backend : :will_paginate } Sobald Sie dann die search verwenden, sind die zurückgegebenen Ergebnisse ein paginierter Satz:
# in your controller
@results = MyModel . search ( 'foo' , hitsPerPage : 10 )
# in your views
# if using will_paginate
<%= will_paginate @results %>
# if using kaminari
<%= paginate @results %> Verwenden Sie die tags -Methode, um Tags zu Ihrem Datensatz hinzuzufügen:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags [ 'trusted' ]
end
endoder mit dynamischen Werten:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags do
[ first_name . blank? || last_name . blank? ? 'partial' : 'full' , has_valid_email? ? 'valid_email' : 'invalid_email' ]
end
end
end Geben Sie zum Zeitpunkt der Abfrage { tagFilters: 'tagvalue' } oder { tagFilters: ['tagvalue1', 'tagvalue2'] } als Suchparameter an, um die Ergebnismenge auf bestimmte Tags einzuschränken.
Facetten können mithilfe der Methode „Extra facets der Suchantwort abgerufen werden.
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# [...]
# specify the list of attributes available for faceting
attributesForFaceting [ :company , :zip_code ]
end
end hits = Contact . search ( 'jon doe' , { facets : '*' } )
p hits # ORM-compliant array of objects
p hits . facets # extra method added to retrieve facets
p hits . facets [ 'company' ] # facet values+count of facet 'company'
p hits . facets [ 'zip_code' ] # facet values+count of facet 'zip_code' raw_json = Contact . raw_search ( 'jon doe' , { facets : '*' } )
p raw_json [ 'facets' ] Sie können auch nach Facettenwerten suchen.
Product . search_for_facet_values ( 'category' , 'Headphones' ) # Array of {value, highlighted, count}Diese Methode kann auch jeden Parameter annehmen, den eine Abfrage annehmen kann. Dadurch wird die Suche auf nur Treffer angepasst, die mit der Suchanfrage übereinstimmen würden.
# Only sends back the categories containing red Apple products (and only counts those)
Product . search_for_facet_values ( 'category' , 'phone' , {
query : 'red' ,
filters : 'brand:Apple'
} ) # Array of phone categories linked to red Apple products Weitere Informationen zu „Distinct for Grouping“ finden Sie hier.
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# [...]
# specify the attribute to be used for distinguishing the records
# in this case the records will be grouped by company
attributeForDistinct "company"
end
end Verwenden Sie die geoloc -Methode, um Ihren Datensatz zu lokalisieren:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
geoloc :lat_attr , :lng_attr
end
end Geben Sie zum Zeitpunkt der Abfrage { aroundLatLng: "37.33, -121.89", aroundRadius: 50000 } als Suchparameter an, um die Ergebnismenge auf 50 km um San Jose einzuschränken.
Jedes Mal, wenn ein Datensatz gespeichert wird, wird er asynchron indiziert. Andererseits wird jedes Mal, wenn ein Datensatz zerstört wird, dieser asynchron aus dem Index entfernt. Das bedeutet, dass ein Netzwerkaufruf mit der ADD/DELETE-Operation synchron an die Algolia-API gesendet wird, die Engine die Operation dann aber asynchron verarbeitet (wenn Sie also direkt danach eine Suche durchführen, spiegeln die Ergebnisse dies möglicherweise noch nicht wider).
Sie können die automatische Indizierung und das automatische Entfernen mithilfe der folgenden Optionen deaktivieren:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch auto_index : false , auto_remove : false do
attribute :first_name , :last_name , :email
end
end Sie können die automatische Indizierung mithilfe des Bereichs without_auto_index vorübergehend deaktivieren. Dies wird häufig aus Leistungsgründen verwendet.
Contact . delete_all
Contact . without_auto_index do
1 . upto ( 10000 ) { Contact . create! attributes } # inside this block, auto indexing task will not run.
end
Contact . reindex! # will use batch operationsSie können den automatischen Indizierungs- und Entfernungsprozess so konfigurieren, dass eine Warteschlange zum Ausführen dieser Vorgänge im Hintergrund verwendet wird. Standardmäßig werden ActiveJob-Warteschlangen (Rails >=4.2) verwendet, Sie können jedoch Ihren eigenen Warteschlangenmechanismus definieren:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : true do # ActiveJob will be triggered using a `algoliasearch` queue
attribute :first_name , :last_name , :email
end
endWenn Sie Aktualisierungen und Löschungen im Hintergrund durchführen, kann eine Datensatzlöschung in Ihrer Datenbank vorgenommen werden, bevor der Job tatsächlich ausgeführt wird. Wenn Sie also den Datensatz laden, um ihn aus der Datenbank zu entfernen, schlägt Ihr ActiveRecord#find mit „RecordNotFound“ fehl.
In diesem Fall können Sie das Laden des Datensatzes aus ActiveRecord umgehen und einfach direkt mit dem Index kommunizieren:
class MySidekiqWorker
def perform ( id , remove )
if remove
# the record has likely already been removed from your database so we cannot
# use ActiveRecord#find to load it
index = AlgoliaSearch . client . init_index ( "index_name" )
index . delete_object ( id )
else
# the record should be present
c = Contact . find ( id )
c . index!
end
end
endWenn Sie Sidekiq verwenden:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : :trigger_sidekiq_worker do
attribute :first_name , :last_name , :email
end
def self . trigger_sidekiq_worker ( record , remove )
MySidekiqWorker . perform_async ( record . id , remove )
end
end
class MySidekiqWorker
def perform ( id , remove )
if remove
# the record has likely already been removed from your database so we cannot
# use ActiveRecord#find to load it
index = AlgoliaSearch . client . init_index ( "index_name" )
index . delete_object ( id )
else
# the record should be present
c = Contact . find ( id )
c . index!
end
end
endWenn Sie „delayed_job“ verwenden:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : :trigger_delayed_job do
attribute :first_name , :last_name , :email
end
def self . trigger_delayed_job ( record , remove )
if remove
record . delay . remove_from_index!
else
record . delay . index!
end
end
end Sie können erzwingen, dass das Indizieren und Entfernen synchron erfolgt (in diesem Fall ruft das Gem die Methode wait_task auf, um sicherzustellen, dass der Vorgang berücksichtigt wurde, sobald die Methode zurückkehrt), indem Sie die folgende Option festlegen: (Dies wird NICHT empfohlen, außer zu Testzwecken )
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch synchronous : true do
attribute :first_name , :last_name , :email
end
end Standardmäßig ist der Indexname der Klassenname, z. B. „Kontakt“. Sie können den Indexnamen anpassen, indem Sie die Option index_name verwenden:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch index_name : "MyCustomName" do
attribute :first_name , :last_name , :email
end
end Mit der folgenden Option können Sie dem Indexnamen die aktuelle Rails-Umgebung anhängen:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true do # index name will be "Contact_#{Rails.env}"
attribute :first_name , :last_name , :email
end
end Sie können einen Block verwenden, um einen komplexen Attributwert anzugeben
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :email
attribute :full_name do
" #{ first_name } #{ last_name } "
end
add_attribute :full_name2
end
def full_name2
" #{ first_name } #{ last_name } "
end
end Hinweise: Sobald Sie solchen Code zum Definieren zusätzlicher Attribute verwenden, kann das Gem nicht mehr erkennen, ob sich das Attribut geändert hat (der Code verwendet #{attribute}_changed? -Methode von Rails, um dies zu erkennen). Infolgedessen wird Ihr Datensatz auch dann an die API übertragen, wenn sich seine Attribute nicht geändert haben. Sie können dieses Verhalten umgehen, indem Sie ein _changed? Verfahren:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :email
attribute :full_name do
" #{ first_name } #{ last_name } "
end
end
def full_name_changed?
first_name_changed? || last_name_changed?
end
end Sie können problemlos verschachtelte Objekte einbetten, die ein zusätzliches Attribut definieren, das ein beliebiges JSON-kompatibles Objekt zurückgibt (ein Array oder einen Hash oder eine Kombination aus beidem).
class Profile < ActiveRecord :: Base
include AlgoliaSearch
belongs_to :user
has_many :specializations
algoliasearch do
attribute :user do
# restrict the nested "user" object to its `name` + `email`
{ name : user . name , email : user . email }
end
attribute :public_specializations do
# build an array of public specialization (include only `title` and `another_attr`)
specializations . select { | s | s . public? } . map do | s |
{ title : s . title , another_attr : s . another_attr }
end
end
end
end Mit ActiveRecord verwenden wir touch und after_touch , um dies zu erreichen.
# app/models/app.rb
class App < ApplicationRecord
include AlgoliaSearch
belongs_to :author , class_name : :User
after_touch :index!
algoliasearch do
attribute :title
attribute :author do
author . as_json
end
end
end
# app/models/user.rb
class User < ApplicationRecord
# If your association uses belongs_to
# - use `touch: true`
# - do not define an `after_save` hook
has_many :apps , foreign_key : :author_id
after_save { apps . each ( & :touch ) }
end Mit Sequel können Sie das touch -Plugin verwenden, um die Änderungen zu verbreiten:
# app/models/app.rb
class App < Sequel :: Model
include AlgoliaSearch
many_to_one :author , class : :User
plugin :timestamps
plugin :touch
algoliasearch do
attribute :title
attribute :author do
author . to_hash
end
end
end
# app/models/user.rb
class User < Sequel :: Model
one_to_many :apps , key : :author_id
plugin :timestamps
# Can't use the associations since it won't trigger the after_save
plugin :touch
# Define the associations that need to be touched here
# Less performant, but allows for the after_save hook to trigger
def touch_associations
apps . map ( & :touch )
end
def touch
super
touch_associations
end
end objectID Standardmäßig basiert die objectID auf id Ihres Datensatzes. Sie können dieses Verhalten ändern, indem Sie die Option :id angeben (verwenden Sie unbedingt ein Uniq-Feld).
class UniqUser < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch id : :uniq_name do
end
end Sie können Einschränkungen hinzufügen, die steuern, ob ein Datensatz indiziert werden muss, indem Sie die Optionen :if oder :unless verwenden.
Sie können damit eine bedingte Indizierung pro Dokument durchführen.
class Post < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published? , unless : :deleted? do
end
def published?
# [...]
end
def deleted?
# [...]
end
end Hinweise: Sobald Sie diese Einschränkungen verwenden, werden addObjects und deleteObjects Aufrufe ausgeführt, um den Index mit der Datenbank synchronisiert zu halten (das zustandslose Gem weiß nicht, ob das Objekt Ihren Einschränkungen nicht mehr entspricht oder nie übereinstimmt , also erzwingen wir das Senden von ADD/DELETE-Vorgängen). Sie können dieses Verhalten umgehen, indem Sie ein _changed? Verfahren:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published do
end
def published
# true or false
end
def published_changed?
# return true only if you know that the 'published' state changed
end
endSie können eine Teilmenge Ihrer Datensätze wie folgt indizieren:
# will generate batch API calls (recommended)
MyModel . where ( 'updated_at > ?' , 10 . minutes . ago ) . reindex!oder
MyModel . index_objects MyModel . limit ( 5 ) Mit der sanitize Option können Sie alle Ihre Attribute bereinigen. Dadurch werden alle HTML-Tags aus Ihren Attributen entfernt.
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , sanitize : true do
attributes :name , :email , :company
end
end Wenn Sie Rails 4.2+ verwenden, müssen Sie auch auf rails-html-sanitizer angewiesen sein:
gem 'rails-html-sanitizer' Mit der Option force_utf8_encoding können Sie die UTF-8-Kodierung aller Ihrer Attribute erzwingen:
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch force_utf8_encoding : true do
attributes :name , :email , :company
end
endHinweise: Diese Option ist nicht mit Ruby 1.8 kompatibel
Sie können Ausnahmen deaktivieren, die beim Versuch, die API von Algolia zu erreichen, ausgelöst werden könnten, indem Sie die Option raise_on_failure verwenden:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
# only raise exceptions in development env
algoliasearch raise_on_failure : Rails . env . development? do
attribute :first_name , :last_name , :email
end
end Hier ist ein reales Konfigurationsbeispiel (von HN Search):
class Item < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true do
# the list of attributes sent to Algolia's API
attribute :created_at , :title , :url , :author , :points , :story_text , :comment_text , :author , :num_comments , :story_id , :story_title
# integer version of the created_at datetime field, to use numerical filtering
attribute :created_at_i do
created_at . to_i
end
# `title` is more important than `{story,comment}_text`, `{story,comment}_text` more than `url`, `url` more than `author`
# btw, do not take into account position in most fields to avoid first word match boost
searchableAttributes [ 'unordered(title)' , 'unordered(story_text)' , 'unordered(comment_text)' , 'unordered(url)' , 'author' ]
# tags used for filtering
tags do
[ item_type , "author_ #{ author } " , "story_ #{ story_id } " ]
end
# use associated number of HN points to sort results (last sort criteria)
customRanking [ 'desc(points)' , 'desc(num_comments)' ]
# google+, $1.5M raises, C#: we love you
separatorsToIndex '+#$'
end
def story_text
item_type_cd != Item . comment ? text : nil
end
def story_title
comment? && story ? story . title : nil
end
def story_url
comment? && story ? story . url : nil
end
def comment_text
comment? ? text : nil
end
def comment?
item_type_cd == Item . comment
end
# [...]
end Sie können die Indizierung über den index! Instanzmethode.
c = Contact . create! ( params [ :contact ] )
c . index! Und lösen Sie das Entfernen des Index mithilfe von „ remove_from_index! Instanzmethode.
c . remove_from_index!
c . destroy Das Gem bietet zwei Möglichkeiten, alle Ihre Objekte neu zu indizieren:
Um alle Ihre Datensätze neu zu indizieren (unter Berücksichtigung der gelöschten Objekte), indiziert die reindex Klassenmethode alle Ihre Objekte in einem temporären Index namens <INDEX_NAME>.tmp und verschiebt den temporären Index in den endgültigen Index, sobald alles (atomar) indiziert ist. Dies ist der sicherste Weg, alle Ihre Inhalte neu zu indizieren.
Contact . reindex Hinweise : Wenn Sie einen indexspezifischen API-Schlüssel verwenden, stellen Sie sicher, dass Sie sowohl <INDEX_NAME> als auch <INDEX_NAME>.tmp zulassen.
Warnung: Sie sollten eine solche atomare Neuindizierungsoperation nicht beim Scoping/Filtern des Modells verwenden, da diese Operation den gesamten Index ersetzt und nur die gefilterten Objekte behält. Das heißt: Machen Sie nicht MyModel.where(...).reindex , sondern MyModel.where(...).reindex! (mit dem nachgestellten ! )!!!
Um alle Ihre Objekte an Ort und Stelle neu zu indizieren (ohne temporären Index und daher ohne gelöschte Objekte), verwenden Sie die reindex! Klassenmethode:
Contact . reindex! Um einen Index zu löschen, verwenden Sie den clear_index! Klassenmethode:
Contact . clear_index! Sie können auf das zugrunde liegende index zugreifen, indem Sie die index aufrufen:
index = Contact . index
# index.get_settings, index.partial_update_object, ... Sie können Replikatindizes mit der Methode add_replica definieren. Verwenden Sie inherit: true für den Replikatblock, wenn dieser von den primären Einstellungen erben soll.
class Book < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch per_environment : true do
searchableAttributes [ :name , :author , :editor ]
# define a replica index to search by `author` only
add_replica 'Book_by_author' , per_environment : true do
searchableAttributes [ :author ]
end
# define a replica index with custom ordering but same settings than the main block
add_replica 'Book_custom_order' , inherit : true , per_environment : true do
customRanking [ 'asc(rank)' ]
end
end
endUm mithilfe einer Replik zu suchen, verwenden Sie den folgenden Code:
Book . raw_search 'foo bar' , replica : 'Book_by_editor'
# or
Book . search 'foo bar' , replica : 'Book_by_editor' Es kann sinnvoll sein, einen Index zwischen mehreren Modellen zu teilen. Um dies zu implementieren, müssen Sie sicherstellen, dass kein Konflikt mit der objectID der zugrunde liegenden Modelle besteht.
class Student < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch index_name : 'people' , id : :algolia_id do
# [...]
end
private
def algolia_id
"student_ #{ id } " # ensure the teacher & student IDs are not conflicting
end
end
class Teacher < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch index_name : 'people' , id : :algolia_id do
# [...]
end
private
def algolia_id
"teacher_ #{ id } " # ensure the teacher & student IDs are not conflicting
end
end Hinweise: Wenn Sie auf einen einzelnen Index aus mehreren Modellen abzielen, dürfen Sie niemals MyModel.reindex und nur MyModel.reindex! . Die reindex verwendet einen temporären Index, um eine atomare Neuindizierung durchzuführen: Wenn Sie sie verwenden, enthält der resultierende Index nur Datensätze für das aktuelle Modell, da die anderen nicht neu indiziert werden.
Mit der Methode add_index können Sie einen Datensatz in mehreren Indizes indizieren:
class Book < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
PUBLIC_INDEX_NAME = "Book_ #{ Rails . env } "
SECURED_INDEX_NAME = "SecuredBook_ #{ Rails . env } "
# store all books in index 'SECURED_INDEX_NAME'
algoliasearch index_name : SECURED_INDEX_NAME do
searchableAttributes [ :name , :author ]
# convert security to tags
tags do
[ released ? 'public' : 'private' , premium ? 'premium' : 'standard' ]
end
# store all 'public' (released and not premium) books in index 'PUBLIC_INDEX_NAME'
add_index PUBLIC_INDEX_NAME , if : :public? do
searchableAttributes [ :name , :author ]
end
end
private
def public?
released && ! premium
end
endUm mit einem zusätzlichen Index zu suchen, verwenden Sie den folgenden Code:
Book . raw_search 'foo bar' , index : 'Book_by_editor'
# or
Book . search 'foo bar' , index : 'Book_by_editor' Um die Spezifikationen auszuführen, legen Sie bitte die Umgebungsvariablen ALGOLIA_APPLICATION_ID und ALGOLIA_API_KEY fest. Da bei den Tests Indizes erstellt und entfernt werden, verwenden Sie NICHT Ihr Produktionskonto.
Wenn Sie alle Indexierungs-API-Aufrufe (Hinzufügen, Aktualisieren und Löschen) deaktivieren möchten, können Sie die Option disable_indexing festlegen:
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , disable_indexing : Rails . env . test? do
end
end
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , disable_indexing : Proc . new { Rails . env . test? || more_complex_condition } do
end
end Sie stoßen auf ein Problem? Bevor Sie sich an den Support wenden, empfehlen wir Ihnen, unsere FAQ zu lesen, wo Sie Antworten auf die häufigsten Probleme und Fallstricke des Kunden finden.
Wenn Sie zu diesem Projekt beitragen möchten, ohne alle seine Abhängigkeiten zu installieren, können Sie unser Docker-Image verwenden. Weitere Informationen finden Sie in unserem speziellen Leitfaden.
