algoliasearch rails
3.0.1
Dokumentasi • Forum Komunitas • Stack Overflow • Laporkan bug • FAQ • Dukungan
Permata ini memungkinkan Anda dengan mudah mengintegrasikan Algolia Search API ke ORM favorit Anda. Ini didasarkan pada permata algoliasearch-client-ruby. Rails 6.x dan 7.x didukung.
Anda mungkin tertarik dengan contoh aplikasi Ruby on Rails yang menyediakan pelengkapan otomatis berbasis autocomplete.js dan halaman hasil pencarian instan berbasis InstantSearch.js : algoliasearch-rails-example.
Anda dapat menemukan referensi lengkapnya di website Algolia.
Pengaturan
Penggunaan
Pilihan
objectID khususIndeks
Pengujian
Pemecahan masalah
gem install algoliasearch-rails Tambahkan permata ke Gemfile Anda:
gem "algoliasearch-rails"Dan jalankan:
bundle install Buat file baru config/initializers/algoliasearch.rb untuk menyiapkan APPLICATION_ID dan API_KEY Anda.
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' }Permata ini kompatibel dengan ActiveRecord, Mongoid, dan Sekuel.
Anda dapat mengonfigurasi berbagai ambang batas waktu dengan mengatur opsi berikut pada waktu inisialisasi:
AlgoliaSearch . configuration = {
application_id : 'YourApplicationID' ,
api_key : 'YourAPIKey' ,
} Permata ini memanfaatkan callback Rails secara ekstensif untuk memicu tugas pengindeksan. Jika Anda menggunakan metode yang melewati panggilan balik after_validation , before_save atau after_commit , perubahan Anda tidak akan diindeks. Misalnya: update_attribute tidak melakukan pemeriksaan validasi, untuk melakukan validasi saat memperbarui gunakan update_attributes .
Semua metode yang dimasukkan oleh modul AlgoliaSearch diawali dengan algolia_ dan diberi alias ke nama pendek terkait jika metode tersebut belum ditentukan.
Contact . algolia_reindex! # <=> Contact.reindex!
Contact . algolia_search ( "jon doe" ) # <=> Contact.search("jon doe") Kode berikut akan membuat indeks Contact dan menambahkan kemampuan pencarian ke model Contact Anda:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attributes :first_name , :last_name , :email
end
end Anda dapat menentukan atribut yang akan dikirim (di sini kami membatasi pada :first_name, :last_name, :email ) atau tidak (dalam hal ini, semua atribut akan dikirim).
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes will be sent
end
end Anda juga dapat menggunakan metode add_attribute untuk mengirim semua atribut model + atribut tambahan:
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 Kami menyediakan banyak cara untuk mengonfigurasi indeks Anda sehingga Anda dapat menyesuaikan relevansi indeks Anda secara keseluruhan. Yang paling penting adalah atribut yang dapat dicari dan atribut yang mencerminkan popularitas rekaman .
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 Untuk mengindeks model, cukup panggil reindex kelas:
Product . reindexUntuk mengindeks semua model, Anda dapat melakukan hal seperti ini:
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 ) Implementasi penelusuran tradisional cenderung memiliki logika dan fungsionalitas penelusuran di backend. Hal ini masuk akal jika pengalaman penelusuran terdiri dari pengguna yang memasukkan kueri penelusuran, menjalankan penelusuran tersebut, dan kemudian dialihkan ke laman hasil penelusuran.
Menerapkan pencarian di backend tidak lagi diperlukan. Faktanya, dalam banyak kasus, hal ini merugikan kinerja karena penambahan jaringan dan latensi pemrosesan. Kami sangat menyarankan penggunaan Klien API JavaScript kami yang mengeluarkan semua permintaan pencarian langsung dari browser pengguna akhir, perangkat seluler, atau klien. Ini akan mengurangi latensi pencarian secara keseluruhan saat membongkar server Anda pada saat yang bersamaan.
Klien JS API adalah bagian dari permata, cukup minta algolia/v3/algoliasearch.min di suatu tempat di manifes JavaScript Anda, misalnya di application.js jika Anda menggunakan Rails 3.1+:
//= require algolia/v3/algoliasearch.minKemudian dalam kode JavaScript Anda dapat melakukan:
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 ) ;
} ) ;Kami baru-baru ini (Maret 2015) merilis versi baru (V3) klien JavaScript kami, jika Anda menggunakan versi sebelumnya (V2), baca panduan migrasi
Catatan: Kami merekomendasikan penggunaan Klien API JavaScript kami untuk melakukan kueri langsung dari browser pengguna akhir tanpa melalui server Anda.
Pencarian mengembalikan objek yang sesuai dengan ORM dan memuatnya kembali dari database Anda. Kami merekomendasikan penggunaan Klien API JavaScript kami untuk melakukan kueri guna mengurangi latensi keseluruhan dan membongkar server Anda.
hits = Contact . search ( "jon doe" )
p hits
p hits . raw_answer # to get the original JSON raw answer Atribut highlight_result ditambahkan ke setiap objek ORM:
hits [ 0 ] . highlight_result [ 'first_name' ] [ 'value' ]Jika Anda ingin mengambil jawaban JSON mentah dari API, tanpa memuat ulang objek dari database, Anda dapat menggunakan:
json_answer = Contact . raw_search ( "jon doe" )
p json_answer
p json_answer [ 'hits' ]
p json_answer [ 'facets' ] Parameter pencarian dapat ditentukan melalui pengaturan indeks secara statis dalam model Anda atau secara dinamis pada waktu pencarian dengan menentukan parameter pencarian sebagai argumen kedua dari metode search :
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 } ) Meskipun kami sangat menyarankan untuk melakukan semua operasi penelusuran (dan juga penomoran halaman) dari frontend Anda menggunakan JavaScript , kami mendukung will_paginate dan kaminari sebagai backend penomoran halaman.
Untuk menggunakan :will_paginate , tentukan :pagination_backend sebagai berikut:
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' , pagination_backend : :will_paginate } Kemudian, segera setelah Anda menggunakan metode search , hasil yang dikembalikan akan berupa kumpulan halaman:
# in your controller
@results = MyModel . search ( 'foo' , hitsPerPage : 10 )
# in your views
# if using will_paginate
<%= will_paginate @results %>
# if using kaminari
<%= paginate @results %> Gunakan metode tags untuk menambahkan tag ke catatan Anda:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags [ 'trusted' ]
end
endatau menggunakan nilai dinamis:
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 Pada waktu kueri, tentukan { tagFilters: 'tagvalue' } atau { tagFilters: ['tagvalue1', 'tagvalue2'] } sebagai parameter penelusuran untuk membatasi kumpulan hasil ke tag tertentu.
Aspek dapat diambil dengan memanggil metode facets tambahan dari jawaban pencarian.
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' ] Anda juga dapat mencari nilai faset.
Product . search_for_facet_values ( 'category' , 'Headphones' ) # Array of {value, highlighted, count}Metode ini juga dapat mengambil parameter apa pun yang dapat diambil oleh kueri. Ini akan menyesuaikan pencarian hanya pada klik yang cocok dengan kueri.
# 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 Info lebih lanjut tentang perbedaan untuk pengelompokan dapat ditemukan di sini.
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 Gunakan metode geoloc untuk melokalkan catatan Anda:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
geoloc :lat_attr , :lng_attr
end
end Pada waktu kueri, tentukan { aroundLatLng: "37.33, -121.89", aroundRadius: 50000 } sebagai parameter penelusuran untuk membatasi hasil yang disetel ke 50KM di sekitar San Jose.
Setiap kali rekaman disimpan, rekaman tersebut akan diindeks secara asinkron . Di sisi lain, setiap kali sebuah record dimusnahkan, record tersebut akan - secara asinkron - dihapus dari indeks. Artinya, panggilan jaringan dengan operasi ADD/DELETE dikirim secara sinkron ke API Algolia, namun kemudian mesin akan memproses operasi tersebut secara asinkron (jadi jika Anda melakukan penelusuran setelahnya, hasilnya mungkin belum mencerminkan hal tersebut).
Anda dapat menonaktifkan pengaturan pengindeksan otomatis dan penghapusan otomatis dengan opsi berikut:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch auto_index : false , auto_remove : false do
attribute :first_name , :last_name , :email
end
end Anda dapat menonaktifkan pengindeksan otomatis untuk sementara menggunakan cakupan without_auto_index . Hal ini sering digunakan untuk alasan kinerja.
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 operationsAnda dapat mengonfigurasi proses pengindeksan otomatis & penghapusan otomatis untuk menggunakan antrean untuk melakukan operasi tersebut di latar belakang. Antrian ActiveJob (Rails >=4.2) digunakan secara default tetapi Anda dapat menentukan mekanisme antrian Anda sendiri:
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
endJika Anda melakukan pembaruan & penghapusan di latar belakang maka penghapusan catatan dapat dilakukan ke database Anda sebelum pekerjaan benar-benar dijalankan. Jadi jika Anda memuat catatan untuk menghapusnya dari database maka ActiveRecord#find Anda akan gagal dengan RecordNotFound.
Dalam hal ini Anda dapat melewati pemuatan catatan dari ActiveRecord dan langsung berkomunikasi dengan indeks:
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
endJika Anda menggunakan Sidekiq:
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
endJika Anda menggunakan pekerjaan_tertunda:
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 Anda dapat memaksa pengindeksan dan penghapusan agar sinkron (dalam hal ini permata akan memanggil metode wait_task untuk memastikan operasi telah diperhitungkan setelah metode kembali) dengan mengatur opsi berikut: (ini TIDAK disarankan, kecuali untuk tujuan pengujian )
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch synchronous : true do
attribute :first_name , :last_name , :email
end
end Secara default, nama indeks akan menjadi nama kelas, misalnya "Kontak". Anda dapat menyesuaikan nama indeks dengan menggunakan opsi index_name :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch index_name : "MyCustomName" do
attribute :first_name , :last_name , :email
end
end Anda dapat menambahkan akhiran nama indeks dengan lingkungan Rails saat ini menggunakan opsi berikut:
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 Anda dapat menggunakan blok untuk menentukan nilai atribut yang kompleks
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 Catatan: Segera setelah Anda menggunakan kode tersebut untuk mendefinisikan atribut tambahan, permata tidak lagi dapat mendeteksi apakah atribut telah berubah (kode menggunakan metode #{attribute}_changed? Rails untuk mendeteksinya). Akibatnya, catatan Anda akan dikirim ke API meskipun atributnya tidak berubah. Anda dapat mengatasi perilaku ini dengan membuat _changed? metode:
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 Anda dapat dengan mudah menyematkan objek bersarang yang mendefinisikan atribut tambahan yang mengembalikan objek apa pun yang sesuai dengan JSON (array atau hash atau kombinasi keduanya).
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 Dengan ActiveRecord, kami akan menggunakan touch dan after_touch untuk mencapai hal ini.
# 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 Dengan Sekuel, Anda dapat menggunakan plugin touch untuk menyebarkan perubahan:
# 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 khusus Secara default, objectID didasarkan pada id rekaman Anda. Anda dapat mengubah perilaku ini dengan menentukan opsi :id (pastikan untuk menggunakan bidang uniq).
class UniqUser < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch id : :uniq_name do
end
end Anda dapat menambahkan batasan yang mengontrol apakah suatu catatan harus diindeks dengan menggunakan opsi opsi :if atau :unless .
Ini memungkinkan Anda melakukan pengindeksan bersyarat berdasarkan per dokumen.
class Post < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published? , unless : :deleted? do
end
def published?
# [...]
end
def deleted?
# [...]
end
end Catatan: Segera setelah Anda menggunakan batasan tersebut, panggilan addObjects dan deleteObjects akan dilakukan untuk menjaga indeks tetap tersinkronisasi dengan DB (Permata tanpa status tidak mengetahui apakah objek tidak lagi cocok dengan batasan Anda atau tidak pernah cocok , jadi kami memaksa operasi ADD/DELETE untuk dikirim). Anda dapat mengatasi perilaku ini dengan membuat _changed? metode:
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
endAnda dapat mengindeks subkumpulan data Anda menggunakan:
# will generate batch API calls (recommended)
MyModel . where ( 'updated_at > ?' , 10 . minutes . ago ) . reindex!atau
MyModel . index_objects MyModel . limit ( 5 ) Anda dapat membersihkan semua atribut Anda menggunakan opsi sanitize . Ini akan menghapus semua tag HTML dari atribut Anda.
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , sanitize : true do
attributes :name , :email , :company
end
end Jika Anda menggunakan Rails 4.2+, Anda juga harus bergantung pada rails-html-sanitizer :
gem 'rails-html-sanitizer' Anda dapat memaksakan pengkodean UTF-8 pada semua atribut Anda menggunakan opsi force_utf8_encoding :
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch force_utf8_encoding : true do
attributes :name , :email , :company
end
endCatatan: Opsi ini tidak kompatibel dengan Ruby 1.8
Anda dapat menonaktifkan pengecualian yang dapat dimunculkan saat mencoba menjangkau API Algolia dengan menggunakan opsi raise_on_failure :
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 Berikut adalah contoh konfigurasi kata nyata (dari 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 Anda dapat memicu pengindeksan menggunakan index! metode contoh.
c = Contact . create! ( params [ :contact ] )
c . index! Dan memicu penghapusan indeks menggunakan remove_from_index! metode contoh.
c . remove_from_index!
c . destroy Permata ini menyediakan 2 cara untuk mengindeks ulang semua objek Anda:
Untuk mengindeks ulang semua catatan Anda (dengan mempertimbangkan objek yang dihapus), metode kelas reindex mengindeks semua objek Anda ke indeks sementara yang disebut <INDEX_NAME>.tmp dan memindahkan indeks sementara ke indeks terakhir setelah semuanya diindeks (secara atomis). Ini adalah cara teraman untuk mengindeks ulang semua konten Anda.
Contact . reindex Catatan : jika Anda menggunakan kunci API khusus indeks, pastikan Anda mengizinkan <INDEX_NAME> dan <INDEX_NAME>.tmp .
Peringatan: Anda tidak boleh menggunakan operasi pengindeksan ulang atomik saat melakukan pelingkupan/pemfilteran model karena operasi ini menggantikan seluruh indeks , dan hanya mempertahankan objek yang difilter. yaitu: Jangan lakukan MyModel.where(...).reindex tetapi lakukan MyModel.where(...).reindex! (dengan tambahan ! )!!!
Untuk mengindeks ulang semua objek Anda di tempatnya (tanpa indeks sementara dan karenanya tanpa menghapus objek yang dihapus), gunakan reindex! metode kelas:
Contact . reindex! Untuk menghapus indeks, gunakan clear_index! metode kelas:
Contact . clear_index! Anda dapat mengakses objek index yang mendasarinya dengan memanggil metode kelas index :
index = Contact . index
# index.get_settings, index.partial_update_object, ... Anda dapat menentukan indeks replika menggunakan metode add_replica . Gunakan inherit: true pada blok replika jika Anda ingin mewarisi dari pengaturan utama.
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
endUntuk mencari menggunakan replika, gunakan kode berikut:
Book . raw_search 'foo bar' , replica : 'Book_by_editor'
# or
Book . search 'foo bar' , replica : 'Book_by_editor' Masuk akal untuk berbagi indeks di antara beberapa model. Untuk mengimplementasikannya, Anda harus memastikan tidak ada konflik dengan objectID model yang mendasarinya.
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 Catatan: Jika Anda menargetkan satu indeks dari beberapa model, Anda tidak boleh menggunakan MyModel.reindex dan hanya menggunakan MyModel.reindex! . Metode reindex menggunakan indeks sementara untuk melakukan pengindeksan ulang atom: jika Anda menggunakannya, indeks yang dihasilkan hanya akan berisi catatan untuk model saat ini karena tidak akan mengindeks ulang yang lain.
Anda dapat mengindeks catatan dalam beberapa indeks menggunakan metode add_index :
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
endUntuk mencari menggunakan indeks tambahan, gunakan kode berikut:
Book . raw_search 'foo bar' , index : 'Book_by_editor'
# or
Book . search 'foo bar' , index : 'Book_by_editor' Untuk menjalankan spesifikasi, harap atur variabel lingkungan ALGOLIA_APPLICATION_ID dan ALGOLIA_API_KEY . Karena pengujian membuat dan menghapus indeks, JANGAN gunakan akun produksi Anda.
Anda mungkin ingin menonaktifkan semua panggilan API pengindeksan (menambah, memperbarui & menghapus operasi), Anda dapat mengatur opsi disable_indexing :
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 Mengalami masalah? Sebelum menghubungi dukungan, kami sarankan untuk membuka FAQ kami di mana Anda akan menemukan jawaban untuk masalah paling umum dan masalah yang dihadapi klien.
Jika Anda ingin berkontribusi pada proyek ini tanpa menginstal semua dependensinya, Anda dapat menggunakan image Docker kami. Silakan periksa panduan khusus kami untuk mempelajari lebih lanjut.
