Hologres:Gunakan Proxima untuk pencarian vektor

Prosedur

1. Hubungkan ke Hologres.

   Hubungkan ke Hologres menggunakan tool pengembangan. Untuk informasi selengkapnya, lihat Hubungkan ke tool pengembangan. Jika Anda menggunakan koneksi Java Database Connectivity (JDBC), gunakan mode Prepare Statement.

2. Instal ekstensi Proxima.

   Proxima terhubung ke Hologres sebagai ekstensi. Sebelum menggunakan Proxima, superuser harus menjalankan perintah berikut untuk menginstal ekstensi Proxima.

   --Install the Proxima extension
   CREATE EXTENSION proxima;

   Ekstensi Proxima diinstal berdasarkan database. Anda hanya perlu menginstalnya sekali untuk setiap database. Untuk menguninstal ekstensi tersebut, jalankan perintah berikut.

   DROP EXTENSION proxima;

   Penting

   Jangan jalankan perintah DROP EXTENSION <extension_name> CASCADE; untuk menguninstal ekstensi. Opsi `CASCADE` menghapus ekstensi yang ditentukan beserta semua data ekstensi dan objek dependen. Data ekstensi dapat mencakup data PostGIS, data RoaringBitmap, data Proxima, data binary logging (Binlog), dan data BSI. Objek dependen dapat mencakup metadata, tabel, tampilan, dan data server.

3. Buat tabel vektor dan indeks vektor.

   Di Hologres, vektor biasanya direpresentasikan sebagai array FLOAT4. Sintaks untuk membuat tabel vektor adalah sebagai berikut.

   Catatan

   • Indeks vektor hanya didukung untuk tabel berorientasi kolom dan tabel hibrida baris-kolom. Indeks ini tidak didukung untuk tabel berorientasi baris.

   • Saat mendefinisikan vektor, dimensi array harus 1. Artinya, parameter input kedua untuk array_ndims dan array_length harus 1.

   • Mulai dari Hologres V2.0.11, Anda dapat mengimpor data sebelum membuat indeks vektor. Metode ini menghindari pembuatan indeks vektor untuk file selama proses compaction dan mempersingkat waktu pembuatan indeks.

   • Buat indeks vektor sebelum mengimpor data: Metode ini cocok untuk skenario data real-time.

     --Set a single index
     BEGIN;
     CREATE TABLE feature_tb (
         id BIGINT,
         feature_col FLOAT4[] CHECK(array_ndims(feature_col) = 1 AND array_length(feature_col, 1) = <value>) --Define a vector
     );
     CALL set_table_property(
     'feature_tb', 
     'proxima_vectors', 
     '{"<feature_col>":{"algorithm":"Graph",
     "distance_method":"<value>",
     "builder_params":{"min_flush_proxima_row_count" : 1000, 
     "min_compaction_proxima_row_count" : 1000, 
     "max_total_size_to_merge_mb" : 2000}}}'); --Build a vector index
     COMMIT;
     
     --Set multiple indexes
     BEGIN;
     CREATE TABLE t1 (
         f1 INT PRIMARY KEY,
         f2 FLOAT4[] NOT NULL CHECK(array_ndims(f2) = 1 AND array_length(f2, 1) = 4),
         f3 FLOAT4[] NOT NULL CHECK(array_ndims(f3) = 1 AND array_length(f3, 1) = 4)
     );
     CALL set_table_property(
     't1',  
     'proxima_vectors', 
     '{"f2":{"algorithm":"Graph",
     "distance_method":"InnerProduct",
     "builder_params":{"min_flush_proxima_row_count" : 1000, 
     "min_compaction_proxima_row_count" : 1000, 
     "max_total_size_to_merge_mb" : 2000}},
     "f3":{"algorithm":"Graph",
     "distance_method":"InnerProduct",
     "builder_params":{"min_flush_proxima_row_count" : 1000, 
     "min_compaction_proxima_row_count" : 1000, 
     "max_total_size_to_merge_mb" : 2000}}}');
     COMMIT;

   • Impor data sebelum membuat indeks vektor: Metode ini cocok untuk skenario analitik batch.

     Catatan

     Mulai dari Hologres V2.1.17, Serverless Computing didukung. Untuk skenario yang melibatkan impor batch atau kueri volume besar data vektor, Anda dapat menggunakan Serverless Computing untuk menjalankan tugas-tugas tersebut. Pendekatan ini menggunakan sumber daya serverless tambahan alih-alih sumber daya instans Anda, sehingga Anda tidak perlu menyisihkan sumber daya komputasi tambahan untuk instans Anda. Hal ini secara signifikan meningkatkan stabilitas instans dan mengurangi kemungkinan error out-of-memory (OOM). Anda hanya dikenai biaya untuk tugas yang dijalankan. Untuk informasi selengkapnya tentang Serverless Computing, lihat Serverless Computing. Untuk informasi tentang cara menggunakan Serverless Computing, lihat Panduan penggunaan Serverless Computing.

     --Set a single index
     BEGIN;
     CREATE TABLE feature_tb (
         id BIGINT,
         feature_col FLOAT4[] CHECK(array_ndims(feature_col) = 1 AND array_length(feature_col, 1) = <value>) --Define a vector
     );
     COMMIT;
     
     -- (Optional) Use Serverless Computing to run large-volume batch import and ETL jobs
     SET hg_computing_resource = 'serverless';
     
     -- Import data
     INSERT INTO feature_tb ...;
     VACUUM feature_tb;
     
     -- Build a vector index
     CALL set_table_property(
     'feature_tb', 
     'proxima_vectors', 
     '{"<feature_col>":{"algorithm":"Graph",
     "distance_method":"<value>",
     "builder_params":{"min_flush_proxima_row_count" : 1000, 
     "min_compaction_proxima_row_count" : 1000, 
     "max_total_size_to_merge_mb" : 2000}}}'); 
     
     -- Reset the configuration to ensure that unnecessary SQL statements do not use serverless resources.
     RESET hg_computing_resource;

   Tabel berikut menjelaskan parameter-parameter tersebut.

   Kategori	Parameter	Deskripsi	Contoh
   Properti vektor dasar	feature_col	Nama kolom vektor.	feature.
   	array_ndims	Dimensi vektor. Hanya vektor satu dimensi yang didukung.	Contoh berikut menunjukkan cara membuat vektor satu dimensi dengan panjang 4. feature float4[] check(array_ndims(feature) = 1 and array_length(feature, 1) = 4)
   	array_length	Panjang vektor. Panjang maksimum adalah 1.000.000.
   Indeks vektor	proxima_vectors	Menentukan bahwa indeks vektor dibangun. Parameter ini mencakup hal-hal berikut: algorithm: Menentukan algoritma untuk membangun indeks vektor. Saat ini, hanya Graph yang didukung. distance_method: Mendefinisikan metode perhitungan jarak yang digunakan untuk membangun indeks vektor. Fungsi jarak berikut didukung: (Direkomendasikan) SquaredEuclidean: Jarak Euclidean kuadrat. Ini memberikan efisiensi kueri tertinggi. Cocok untuk kueri yang menggunakan pm_approx_squared_euclidean_distance. Euclidean: Jarak Euclidean. Hanya cocok untuk kueri yang menggunakan pm_approx_euclidean_distance. Jika Anda menggunakan fungsi jarak lain, indeks tidak akan digunakan. (Tidak direkomendasikan) InnerProduct: Jarak hasil kali dalam. Ini dikonversi menjadi perhitungan jarak Euclidean pada lapisan dasar. Hal ini menambahkan overhead komputasi tambahan baik pada pembuatan indeks maupun kueri indeks, sehingga tidak efisien. Hindari penggunaan metode ini kecuali ada kebutuhan bisnis yang kuat. Hanya cocok untuk kueri yang menggunakan pm_approx_inner_product_distance. builder_params: Mengontrol parameter untuk pembuatan indeks. Ini adalah string berformat JSON yang berisi parameter berikut. min_flush_proxima_row_count: Jumlah minimum baris yang diperlukan untuk membangun indeks saat data ditulis ke disk. Nilai yang direkomendasikan adalah 1000. min_compaction_proxima_row_count: Jumlah minimum baris yang diperlukan untuk membangun indeks saat data digabung di disk. Nilai yang direkomendasikan adalah 1000. max_total_size_to_merge_mb: Ukuran file maksimum untuk penggabungan data di disk. Satuan: MB. Nilai yang direkomendasikan adalah 2000. proxima_builder_thread_count: Mengontrol jumlah thread yang digunakan untuk membangun indeks vektor selama penulisan data. Nilai default adalah 4. Anda tidak perlu mengubah nilai ini dalam sebagian besar skenario. Catatan Indeks bekerja paling baik dalam skenario tertentu.	Contoh berikut menunjukkan cara membangun indeks vektor untuk kueri yang menggunakan jarak Euclidean kuadrat. call set_table_property( 'feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph", "distance_method":"SquaredEuclidean", "builder_params":{"min_flush_proxima_row_count" : 1000, "min_compaction_proxima_row_count" : 1000, "max_total_size_to_merge_mb" : 2000}}}');

4. Impor data vektor.

   Anda dapat mengimpor data ke tabel vektor secara batch atau real-time. Pilih metode sinkronisasi berdasarkan kebutuhan Anda. Setelah impor batch, jalankan perintah `VACUUM` dan `ANALYZE` untuk meningkatkan efisiensi kueri.

   • `VACUUM` mengompaksi file backend menjadi file yang lebih besar agar kueri lebih efisien. Namun, `VACUUM` mengonsumsi sumber daya CPU. Semakin besar volume data tabel, semakin lama operasi `VACUUM` berjalan. Jika operasi `VACUUM` sedang berjalan, tunggu hingga selesai.

     VACUUM <tablename>;

   • `ANALYZE` mengumpulkan statistik performa. Query Optimizer (QO) menggunakan statistik ini untuk menghasilkan rencana eksekusi yang lebih baik dan meningkatkan performa kueri.

     analyze <tablename>;

5. Kueri data vektor.

   Hologres mendukung kueri vektor eksak dan perkiraan. Fungsi yang ditentukan pengguna (UDF) yang diawali dengan pm_ digunakan untuk kueri eksak, sedangkan UDF yang diawali dengan pm_approx_ digunakan untuk kueri perkiraan. Hanya kueri perkiraan yang diawali dengan pm_approx_ yang dapat menggunakan indeks vektor. Dalam skenario di mana indeks vektor telah dibangun, gunakan kueri perkiraan untuk efisiensi yang lebih tinggi. Indeks vektor hanya dapat digunakan dalam kueri tabel tunggal. Oleh karena itu, gunakan kueri vektor tabel tunggal dan hindari operasi join.

   • Kueri perkiraan (menggunakan indeks vektor)

     Kueri perkiraan dapat menggunakan indeks vektor. Kueri ini cocok untuk skenario yang memindai sejumlah besar data dan memerlukan efisiensi eksekusi tinggi. Tingkat recall default lebih dari 99%. Untuk menggunakan indeks vektor, tambahkan awalan approx_ ke fungsi jarak yang sesuai. Fungsi jarak yang didukung adalah sebagai berikut:

     Catatan

     • Untuk kueri perkiraan yang menggunakan jarak Euclidean kuadrat atau jarak Euclidean, indeks vektor hanya dapat digunakan ketika Anda menentukan order by distance asc. Urutan menurun tidak didukung.

     • Untuk kueri perkiraan yang menggunakan jarak hasil kali dalam, indeks vektor hanya dapat digunakan ketika Anda menentukan order by distance desc. Urutan menaik tidak didukung.

     FLOAT4 pm_approx_squared_euclidean_distance(FLOAT4[], FLOAT4[])
     FLOAT4 pm_approx_euclidean_distance(FLOAT4[], FLOAT4[])
     FLOAT4 pm_approx_inner_product_distance(FLOAT4[], FLOAT4[])

     Fungsi yang digunakan dalam kueri harus sesuai dengan distance_method dari parameter proxima_vector yang ditentukan saat tabel dibuat. Contoh berikut menunjukkan cara mengkueri hasil top N. Dalam kueri perkiraan, parameter kedua harus berupa nilai konstan.

     Catatan

     Kueri indeks bersifat lossy dan dapat menyebabkan hilangnya presisi. Tingkat recall default biasanya lebih dari 99%.

     -- Calculate the TOP K for squared Euclidean distance. The distance_method in the proxima_vector parameter must be SquaredEuclidean when the table is created.
     SELECT pm_approx_squared_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
     
     -- Calculate the TOP K for Euclidean distance. The distance_method in the proxima_vector parameter must be Euclidean when the table is created.
     SELECT pm_approx_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
     
     -- Calculate the TOP K for inner product distance. The distance_method in the proxima_vector parameter must be InnerProduct when the table is created.
     SELECT pm_approx_inner_product_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance DESC limit 10 ;

   • Kueri eksak (tidak menggunakan indeks vektor)

     Kueri eksak cocok untuk skenario di mana pernyataan SQL memindai sejumlah kecil data dan memerlukan tingkat recall tinggi. Tiga fungsi jarak berikut sesuai dengan metode perhitungan jarak Euclidean, jarak Euclidean kuadrat, dan jarak hasil kali dalam:

     FLOAT4 pm_squared_euclidean_distance(FLOAT4[], FLOAT4[])
     FLOAT4 pm_euclidean_distance(FLOAT4[], FLOAT4[])
     FLOAT4 pm_inner_product_distance(FLOAT4[], FLOAT4[])

     Untuk mengambil tetangga terdekat top K untuk vektor target, gunakan pernyataan SQL berikut.

     Catatan

     Pernyataan SQL contoh melakukan perhitungan recall eksak. Proses eksekusinya adalah sebagai berikut: memindai semua vektor di kolom `feature` untuk menghitung jarak, mengurutkan hasilnya, lalu mengembalikan 10 catatan teratas. Jenis pernyataan SQL ini cocok untuk skenario dengan volume data kecil dan memerlukan tingkat recall sangat tinggi.

     -- Retrieve the 10 nearest neighbors by squared Euclidean distance
     SELECT pm_squared_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
     
     -- Retrieve the 10 nearest neighbors by Euclidean distance
     SELECT pm_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
     
     -- Retrieve the 10 neighbors with the largest inner product distance
     SELECT pm_inner_product_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance DESC limit 10 ;

Contoh lengkap

Contoh ini menunjukkan cara menggunakan indeks Proxima untuk mengambil 40 vektor terdekat dari tabel vektor yang berisi 100.000 vektor berdimensi 4 berdasarkan jarak Euclidean kuadrat.

1. Buat tabel vektor.

   CREATE EXTENSION proxima;
   
   BEGIN;
   -- Create a table group with shard_count = 4
   CALL HG_CREATE_TABLE_GROUP ('test_tg_shard_4', 4);
   CREATE TABLE feature_tb (
       id BIGINT,
       feature FLOAT4[] CHECK (array_ndims(feature) = 1 AND array_length(feature, 1) = 4)
   );
   CALL set_table_property ('feature_tb', 'table_group', 'test_tg_shard_4');
   CALL set_table_property ('feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph","distance_method":"SquaredEuclidean","builder_params":
   												{"min_flush_proxima_row_count" : 1000, "min_compaction_proxima_row_count" : 1000, "max_total_size_to_merge_mb" : 2000}}}');
   COMMIT;

2. Impor data.

   -- (Optional) Use Serverless Computing to run large-volume batch import and ETL jobs
   SET hg_computing_resource = 'serverless';
   
   INSERT INTO feature_tb
   SELECT
       i,
       ARRAY[random(), random(), random(), random()]::FLOAT4[]
   FROM
       generate_series(1, 100000) i;
   
   ANALYZE feature_tb;
   
   VACUUM feature_tb;
   
   -- Reset the configuration to ensure that unnecessary SQL statements do not use serverless resources.
   RESET hg_computing_resource;

3. Jalankan kueri.

   -- (Optional) Use Serverless Computing to run a large-volume vector query job
   SET hg_computing_resource = 'serverless';
   
   SELECT
       pm_approx_squared_euclidean_distance (feature, '{0.1,0.2,0.3,0.4}') AS distance
   FROM
       feature_tb
   ORDER BY
       distance
   LIMIT 40;
   
   -- Reset the configuration to ensure that unnecessary SQL statements do not use serverless resources.
   RESET hg_computing_resource;

Tuning performa

• Skenario untuk menetapkan indeks vektor

  Jika volume data kecil, misalnya puluhan ribu catatan, Anda dapat menghitung jarak secara langsung tanpa menetapkan indeks. Anda juga dapat melakukan perhitungan langsung jika instans Anda memiliki sumber daya yang cukup dan jumlah data yang akan dikueri kecil. Jika perhitungan langsung tidak dapat memenuhi kebutuhan latensi atau throughput Anda, pertimbangkan untuk menggunakan indeks Proxima. Namun, perhatikan hal-hal berikut:

  • Proxima adalah indeks lossy dan tidak menjamin keakuratan hasil. Jarak yang dihitung mungkin memiliki bias.

  • Indeks Proxima dapat menyebabkan jumlah catatan yang direcall tidak mencukupi. Misalnya, jika Anda menentukan limit 1000, hanya 500 catatan yang mungkin dikembalikan.

  • Indeks Proxima dapat sulit digunakan.

• Tetapkan jumlah shard yang sesuai

  Semakin banyak shard, semakin banyak file indeks Proxima yang dibangun, yang menurunkan throughput kueri. Dalam praktiknya, tetapkan jumlah shard yang wajar berdasarkan sumber daya instans Anda. Biasanya, Anda dapat menetapkan jumlah shard sama dengan jumlah worker. Misalnya, untuk instans 64-core, Anda dapat menetapkan jumlah shard menjadi 4. Untuk mengurangi latensi kueri tunggal, Anda dapat mengurangi jumlah shard, tetapi ini juga mengurangi performa penulisan.

  -- Create a vector table and place it in a table group with shard_count = 4
  BEGIN;
  CALL HG_CREATE_TABLE_GROUP ('test_tg_shard_4', 4);
  CREATE TABLE proxima_test (
      id BIGINT NOT NULL,
      vectors FLOAT4[] CHECK (array_ndims(vectors) = 1 AND array_length(vectors, 1) = 128),
      PRIMARY KEY (id)
  );
  CALL set_table_property ('proxima_test', 'proxima_vectors', '{"vectors":{"algorithm":"Graph","distance_method":"SquaredEuclidean","builder_params":{}, "searcher_init_params":{}}}');
  CALL set_table_property ('proxima_test', 'table_group', 'test_tg_shard_4');
  COMMIT;

• (Direkomendasikan) Skenario kueri tanpa kondisi filter

  Kondisi filter where dapat memengaruhi penggunaan indeks dan menghasilkan performa yang lebih buruk. Oleh karena itu, kami merekomendasikan penggunaan kueri tanpa kondisi filter. Untuk pengambilan vektor tanpa kondisi filter, kondisi ideal adalah hanya memiliki satu file indeks vektor di setiap shard. Dengan demikian, kueri dapat diproses pada satu shard saja.

  Untuk skenario kueri tanpa kondisi filter, Anda biasanya dapat membuat tabel sebagai berikut.

  BEGIN;
  CREATE TABLE feature_tb (
      uuid text,
      feature FLOAT4[] NOT NULL CHECK (array_ndims(feature) = 1 AND array_length(feature, 1) = N) --Define a vector
  );
  CALL set_table_property ('feature_tb', 'shard_count', '?'); --Specify the shard count. Set it reasonably based on your business needs. If not needed, you can omit this.
  CALL set_table_property ('feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph","distance_method":"InnerProduct"}'); --Build a vector index
  END;                 

• Skenario kueri dengan kondisi filter

  Untuk pengambilan vektor dengan kondisi filter, skenario tersebut dapat dipecah menjadi skenario penyaringan umum berikut.

  • Skenario kueri 1: Kolom string digunakan sebagai kondisi filter

    Berikut adalah contoh kueri. Skenario umum adalah menemukan data vektor yang sesuai dalam suatu organisasi, seperti menemukan data wajah dalam kelas tertentu.

    SELECT pm_xx_distance(feature, '{1,2,3,4}') AS d FROM feature_tb WHERE uuid = 'x' ORDER BY d limit 10;

    Kami merekomendasikan optimasi berikut.

    • Tetapkan `uuid` sebagai kunci distribusi. Hal ini memastikan bahwa data dengan kondisi filter yang sama disimpan di shard yang sama. Kueri kemudian diproses pada satu shard.

    • Tetapkan `uuid` sebagai kunci pengelompokan untuk tabel. Data kemudian diurutkan dalam file berdasarkan kunci pengelompokan.

  • Skenario kueri 2: Bidang waktu digunakan sebagai kondisi filter

    Berikut adalah contoh kueri. Biasanya, bidang waktu digunakan untuk menyaring data vektor yang sesuai. Anda dapat menetapkan bidang waktu `time_field` sebagai kunci segmen untuk tabel. Hal ini memungkinkan Anda dengan cepat menemukan file tempat data disimpan.

    SELECT pm_xx_distance(feature, '{1,2,3,4}') AS d FROM feature_tb WHERE time_field BETWEEN '2020-08-30 00:00:00' AND '2020-08-30 12:00:00' ORDER BY d limit 10;

  Oleh karena itu, untuk pengambilan vektor dengan kondisi filter, Anda biasanya dapat membuat tabel sebagai berikut.

  BEGIN;
  CREATE TABLE feature_tb (
      time_field timestamptz NOT NULL,
      uuid text,
      feature FLOAT4[] NOT NULL CHECK (array_ndims(feature) = 1 AND array_length(feature, 1) = N)
  );
  CALL set_table_property ('feature_tb', 'distribution_key', 'uuid');
  CALL set_table_property ('feature_tb', 'segment_key', 'time_field');
  CALL set_table_property ('feature_tb', 'clustering_key', 'uuid');
  CALL set_table_property ('feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph","distance_method":"InnerProduct"}}');
  COMMIT;
  
  -- If you do not filter by time, you can delete the index related to time_field.

FAQ

• Error: ERROR: function pm_approx_inner_product_distance(real[], unknown) does not exist.

  Penyebab: Error ini biasanya terjadi karena pernyataan create extension proxima; belum dijalankan di database untuk menginisialisasi ekstensi Proxima.

  Solusi: Jalankan pernyataan create extension proxima; untuk menginisialisasi ekstensi Proxima.

• Error: Writing column: feature with array size: 5 violates fixed size list (4) constraint declared in schema.

  Penyebab: Error ini terjadi karena dimensi data yang ditulis ke kolom vektor fitur tidak sesuai dengan dimensi yang didefinisikan di tabel.

  Solusi: Periksa adanya data kotor.

• Error: The size of two arrays must be the same in DistanceFunction, size of left array: 4, size of right array:.

  Penyebab: Dimensi `left` tidak sesuai dengan dimensi `right` di pm_xx_distance(left, right).

  Solusi: Pastikan dimensi `left` sesuai dengan dimensi `right` di pm_xx_distance(left, right).

• Error penulisan real-time: BackPressure Exceed Reject Limit ctxId: XXXXXXXX, tableId: YY, shardId: ZZ.

  Penyebab: Tugas penulisan real-time mengalami bottleneck, yang menyebabkan exception backpressure. Exception ini menunjukkan bahwa tugas penulisan memiliki overhead tinggi dan lambat. Masalah ini biasanya terjadi karena nilai min_flush_proxima_row_count kecil sementara kecepatan penulisan real-time tinggi. Hal ini menyebabkan overhead tinggi untuk pembuatan indeks real-time dan menghambat proses penulisan real-time.

  Solusi: Tingkatkan nilai min_flush_proxima_row_count.

• Bagaimana cara menulis data vektor menggunakan Java?

  Contoh berikut menunjukkan cara menulis data vektor menggunakan Java.

  private static void insertIntoVector(Connection conn) throws Exception {
      try (PreparedStatement stmt = conn.prepareStatement("insert into feature_tb values(?,?);")) {
          for (int i = 0; i < 100; ++i) {
             stmt.setInt(1, i);
             Float[] featureVector = {0.1f,0.2f,0.3f,0.4f};
             Array array = conn.createArrayOf("FLOAT4", featureVector);
             stmt.setArray(2, array);
             stmt.execute();
          }
      }
  }

• Bagaimana cara memeriksa apakah indeks Proxima digunakan dengan melihat rencana eksekusi?

  Jika rencana eksekusi berisi Proxima filter: xxxx, indeks digunakan, seperti yang ditunjukkan pada gambar berikut. Jika tidak, indeks tidak digunakan. Masalah ini biasanya terjadi karena pernyataan pembuatan tabel tidak sesuai dengan pernyataan kueri.

Deskripsi fungsi jarak

Hologres mendukung tiga fungsi jarak vektor berikut:

• Jarak Euclidean kuadrat (SquaredEuclidean). Rumusnya sebagai berikut.

• Jarak Euclidean (Euclidean). Rumusnya sebagai berikut.

• Jarak hasil kali dalam (InnerProduct). Rumusnya sebagai berikut.