rails-paradedb 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61970bcefe75f0514836a81ab38dd8e39fe1c6f311d55f35366120d2285325b9
-  data.tar.gz: 6179c3b6d0814dcaae1179977548c4b47e6f6447110596293f242d668727d79a
+  metadata.gz: 87745906c0e84ce264fcb243665c8edaf756218568745eecbe2781b0aa35f52f
+  data.tar.gz: 499f1837259b7a2c2a56ff6c55a98ff8dc6ef72e9de08517631215d9a7c091c2
 SHA512:
-  metadata.gz: 38471cccf3d392cd481dbb22cde9f35c37f09a555c4e6081c5484d9c5ad1920082172276447a2401a22c0dd46bcd1a0846f2dee26678f556f913373996a91da0
-  data.tar.gz: 6176c6252901db66d8f8dd72972f8053fc6a187d0d10391705dde18fabe16a4992d60655a351b3af8643e9ca4a57c2baff58a11a2dd93cb63a708750785034c6
+  metadata.gz: ffcfe007ab852d8b36f69e9af1853dc1b0df485bfdbb0599749aa6ee27e1dd43707ea8958733c6b4c112fdd3d2ba6038d460dfb8c3062475e53826164d54a3f7
+  data.tar.gz: 236e0df31d2f705f3b7f015e5c051951e4aec16e3438961e5ff2a2757ab007f3a21565c312847aaa26fc844d3fd9c16e3c732634ba2d1d9b3c4a00f9a30263a9

data/CHANGELOG.md

@@ -2,13 +2,37 @@
 
 All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.13.0] - 2026-10-07
+
+### Added
+
+- Index partitioning, target segment count, and vector quantization configuration.
+- Vector storage, configuration, and estimator diagnostics, plus aggregation visibility modes.
+- Snippet-position pagination with `limit` and `offset`.
+- Index layer sizes, background layer sizes, and mutable segment row limits.
+- Index search tokenizer configuration.
+
+### Changed
+
+- **Breaking:** Remove the key-field setting from index definitions, migration helpers, and schema dumps. Query helpers use the model primary key. Require ParadeDB 0.26.0 or newer.
+- **Breaking:** Update vector index build options to `training_sample_ratio` and `max_leaf_size` for ParadeDB 0.26.0 and remove the obsolete cluster replication option.
+
+## [0.12.0] - 2026-08-13
+
+### Changed
+
+- **BREAKING**: Search modifiers are now composable functions: `ParadeDB.boost`, `ParadeDB.constant`, `ParadeDB.fuzzy`, `ParadeDB.slop`, and `ParadeDB.tokenize`. Pass the wrapped value to search methods instead of using modifier keyword arguments.
+- **BREAKING**: Removed the public `ParadeDB::Arel` builder, Arel attribute predications, and `Model.paradedb_arel`. ParadeDB queries now use a private builder composed from standard Active Record nodes.
+
 ## [0.11.0] - 2026-08-04
 
 ### Added
 
 - Vector index build options `centroid_ratio`, `training_samples_per_centroid`, and `cluster_replication` in `ParadeDB::Index` `index_options` and `add_paradedb_index` (pg_search 0.25.0+). They are emitted in the `WITH (...)` clause and round-tripped through the schema dumper.
 
-[0.10.0] - 2026-08-04
+## [0.10.0] - 2026-08-04
 
 ### Added
 
@@ -24,7 +48,7 @@ All notable changes to this project will be documented in this file. The format
 - **BREAKING**: Index creation always emits `USING paradedb`, which requires pg_search 0.25.0+. There is no option to select the legacy `bm25` access method.
 - **BREAKING**: The default index name is now `<table>_search_idx` (previously `<table>_bm25_idx`), and the index generator emits `Create<Model>SearchIndex` migrations named `create_<table>_search_index.rb`.
 
-[0.9.0] - 2026-07-14
+## [0.9.0] - 2026-07-14
 
 ### Added
 
@@ -174,6 +198,8 @@ All notable changes to this project will be documented in this file. The format
 - Schema dump/load round-trip for tokenizer configuration and index options
   (including `target_segment_count`)
 
+[0.13.0]: https://github.com/paradedb/rails-paradedb/releases/tag/v0.13.0
+[0.12.0]: https://github.com/paradedb/rails-paradedb/releases/tag/v0.12.0
 [0.11.0]: https://github.com/paradedb/rails-paradedb/releases/tag/v0.11.0
 [0.10.0]: https://github.com/paradedb/rails-paradedb/releases/tag/v0.10.0
 [0.9.0]: https://github.com/paradedb/rails-paradedb/releases/tag/v0.9.0

data/README.md

@@ -10,16 +10,16 @@
 </h1>
 
 <p align="center">
-  <b>Search without a second system.</b><br/>
+  <b>Just use Postgres.</b><br/>
   One Postgres for your application data, full-text search, vector retrieval, and aggregations.
 </p>
 
 <h3 align="center">
   <a href="https://paradedb.com">Website</a> &bull;
-  <a href="https://docs.paradedb.com">Docs</a> &bull;
+  <a href="https://www.paradedb.com/docs/start/introduction">Docs</a> &bull;
   <a href="https://paradedb.com/slack/">Community</a> &bull;
   <a href="https://paradedb.com/blog/">Blog</a> &bull;
-  <a href="https://docs.paradedb.com/changelog/">Changelog</a>
+  <a href="https://www.paradedb.com/docs/project/changelog">Changelog</a>
 </h3>
 
 <p align="center">
@@ -36,47 +36,25 @@
 
 ## ParadeDB for Rails
 
-The official ActiveRecord integration for [ParadeDB](https://paradedb.com) (powered by the [`pg_search`](https://github.com/paradedb/paradedb) Postgres extension), including first-class support for managing ParadeDB indexes and running queries using the full ParadeDB API. Follow the [getting started guide](https://docs.paradedb.com/documentation/getting-started/environment#rails) to begin.
+The official [ActiveRecord](https://guides.rubyonrails.org/active_record_basics.html) integration for ParadeDB. Get started with the [setup guide](https://www.paradedb.com/docs/start/connect-your-app#rails).
 
 ## Requirements & Compatibility
 
-| Component  | Supported                                                         |
-| ---------- | ----------------------------------------------------------------- |
-| Ruby       | 3.2+                                                              |
-| Rails      | 7.2+                                                              |
-| ParadeDB   | 0.25.0+                                                           |
-| PostgreSQL | 15+ (PostgreSQL adapter with ParadeDB extension)                  |
-| pgvector   | Required for vector search; included in the ParadeDB Docker image |
-
-## Vector Search
-
-rails-paradedb supports full-text search and vector search over pgvector `vector(n)` columns. See the [vector search documentation](https://docs.paradedb.com/documentation/vector/overview) for details.
-
-## Examples
-
-- [Quickstart](examples/quickstart/quickstart.rb)
-- [Vector Search](examples/vector_search/vector_search.rb)
-- [Faceted Search](examples/faceted_search/faceted_search.rb)
-- [Autocomplete](examples/autocomplete/autocomplete.rb)
-- [More Like This](examples/more_like_this/more_like_this.rb)
-- [Hybrid Search (RRF)](examples/hybrid_rrf/hybrid_rrf.rb)
-- [RAG](examples/rag/rag.rb)
+| Component            | Supported                                                                                                                     |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| Ruby                 | 3.2+                                                                                                                          |
+| Rails                | 7.2+                                                                                                                          |
+| PostgreSQL           | 15+                                                                                                                           |
+| pgvector             | 0.7.0+ (provides vector types for ParadeDB’s [native vector search](https://www.paradedb.com/docs/reference/vector/overview)) |
+| ParadeDB / pg_search | 0.26.0+                                                                                                                       |
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, test commands, linting, and PR workflow.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, running tests, linting, and the PR workflow.
 
 ## Support
 
-If you're missing a feature or have found a bug, open a
-[GitHub Issue](https://github.com/paradedb/rails-paradedb/issues/new/choose).
-
-For community support:
-
-- Join the [ParadeDB Slack Community](https://paradedb.com/slack)
-- Ask in [ParadeDB Discussions](https://github.com/paradedb/paradedb/discussions)
-
-For commercial support, contact [sales@paradedb.com](mailto:sales@paradedb.com).
+If you're missing a feature or have found a bug, please open a [GitHub Issue](https://github.com/paradedb/rails-paradedb/issues/new/choose). For community support, join the [ParadeDB Slack Community](https://paradedb.com/slack).
 
 ## Acknowledgments
 

data/lib/generators/parade_db/index/templates/index.rb.tt

@@ -2,7 +2,6 @@
 
 class <%= class_name %>Index < ParadeDB::Index
   self.table_name = :<%= table_name %>
-  self.key_field  = :id
   self.fields     = {
     id: {},
 <% fields.each do |field| -%>

data/lib/parade_db/aggregations.rb

@@ -7,14 +7,7 @@ module ParadeDB
       # Backward-compatible reader for code that accessed `filtered_spec.filter`.
       alias filter agg_filter
     end
-    FieldTermFilter = Struct.new(
-      :field,
-      :term,
-      :distance,
-      :prefix,
-      :transposition_cost_one,
-      keyword_init: true
-    )
+    FieldTermFilter = Struct.new(:field, :term, keyword_init: true)
 
     TERMS_ORDER = {
       count_desc: { "_count" => "desc" },
@@ -154,16 +147,9 @@ module ParadeDB
       { "top_hits" => payload }
     end
 
-    def filtered(spec, filter: nil, field: nil, term: nil, distance: nil, prefix: nil, transposition_cost_one: nil)
+    def filtered(spec, filter: nil, field: nil, term: nil)
       normalized_spec = normalize_spec(spec)
-      normalized_filter = normalize_filter(
-        filter: filter,
-        field: field,
-        term: term,
-        distance: distance,
-        prefix: prefix,
-        transposition_cost_one: transposition_cost_one
-      )
+      normalized_filter = normalize_filter(filter: filter, field: field, term: term)
       FilteredSpec.new(spec: normalized_spec, agg_filter: normalized_filter)
     end
 
@@ -211,7 +197,7 @@ module ParadeDB
     end
     private_class_method :normalize_spec
 
-    def normalize_filter(filter:, field:, term:, distance:, prefix:, transposition_cost_one:)
+    def normalize_filter(filter:, field:, term:)
       if filter
         if !field.nil? || !term.nil?
           raise ArgumentError, "filtered aggregation accepts either filter: or field/term arguments, not both"
@@ -223,17 +209,7 @@ module ParadeDB
         raise ArgumentError, "filtered aggregation requires filter: or both field: and term:"
       end
 
-      normalized_distance = distance.nil? ? nil : normalize_non_negative_integer(distance, "distance")
-      normalized_prefix = normalize_boolean_option(prefix, "prefix")
-      normalized_transposition = normalize_boolean_option(transposition_cost_one, "transposition_cost_one")
-
-      FieldTermFilter.new(
-        field: normalize_field(field),
-        term: term,
-        distance: normalized_distance,
-        prefix: normalized_prefix,
-        transposition_cost_one: normalized_transposition
-      )
+      FieldTermFilter.new(field: normalize_field(field), term: term)
     end
     private_class_method :normalize_filter
 
@@ -318,14 +294,6 @@ module ParadeDB
     end
     private_class_method :normalize_sort_direction
 
-    def normalize_boolean_option(value, name)
-      return nil if value.nil?
-      return value if value == true || value == false
-
-      raise ArgumentError, "#{name} must be true, false, or nil"
-    end
-    private_class_method :normalize_boolean_option
-
     def deep_stringify(value)
       case value
       when Hash

data/lib/parade_db/diagnostics.rb

@@ -13,6 +13,25 @@ module ParadeDB
       execute_table_function(connection, sql)
     end
 
+    def vector_info(index, field, connection: ActiveRecord::Base.connection)
+      args = "#{connection.quote(index.to_s)}::regclass, #{connection.quote(field.to_s)}::text"
+      execute_table_function(connection, "SELECT * FROM paradedb.vector_info(#{args})")
+    end
+
+    def vector_config(index, field, connection: ActiveRecord::Base.connection)
+      args = "#{connection.quote(index.to_s)}::regclass, #{connection.quote(field.to_s)}::text"
+      execute_table_function(connection, "SELECT * FROM paradedb.vector_config(#{args})")
+    end
+
+    def vector_estimator_info(index, field, queries: nil, connection: ActiveRecord::Base.connection)
+      args = "#{connection.quote(index.to_s)}::regclass, #{connection.quote(field.to_s)}::text"
+      unless queries.nil?
+        vectors = queries.map { |query| connection.quote("[#{query.map { |value| Float(value) }.join(',')}]") }
+        args += ", ARRAY[#{vectors.join(', ')}]::vector[]"
+      end
+      execute_table_function(connection, "SELECT * FROM paradedb.vector_estimator_info(#{args})")
+    end
+
     def verify_index(
       index,
       heapallindexed: false,

data/lib/parade_db/index.rb

@@ -6,16 +6,12 @@ require_relative "vector"
 module ParadeDB
   class Index
     class << self
-      attr_writer :table_name, :key_field, :index_name, :fields, :index_options, :where
+      attr_writer :table_name, :index_name, :fields, :index_options, :where
 
       def table_name
         @table_name
       end
 
-      def key_field
-        @key_field
-      end
-
       def index_name
         @index_name || default_index_name
       end
@@ -83,15 +79,14 @@ module ParadeDB
     # Consumed by migration helpers; validates and normalizes the DSL class
     class DefinitionCompiler
       FIELD_OPTION_KEYS = %i[fast record normalizer expand_dots].freeze
-      INDEX_OPTION_KEYS = %i[target_segment_count centroid_ratio training_samples_per_centroid cluster_replication].freeze
-      POSITIVE_INTEGER_INDEX_OPTION_KEYS = %i[target_segment_count training_samples_per_centroid cluster_replication].freeze
+      INDEX_OPTION_KEYS = %i[target_segment_count training_sample_ratio max_leaf_size partition_by vector_fields search_tokenizer layer_sizes background_layer_sizes mutable_segment_rows].freeze
+      POSITIVE_INTEGER_INDEX_OPTION_KEYS = %i[target_segment_count max_leaf_size].freeze
 
       class Compiled
-        attr_reader :table_name, :key_field, :index_name, :entries, :index_options, :field_options, :where
+        attr_reader :table_name, :index_name, :entries, :index_options, :field_options, :where
 
-        def initialize(table_name:, key_field:, index_name:, entries:, index_options:, field_options:, where:)
+        def initialize(table_name:, index_name:, entries:, index_options:, field_options:, where:)
           @table_name = table_name
-          @key_field = key_field
           @index_name = index_name
           @entries = entries
           @index_options = index_options
@@ -104,7 +99,6 @@ module ParadeDB
       class << self
         def compile!(klass)
           table_name = require_symbol!(klass.table_name, "table_name")
-          key_field = require_symbol!(klass.key_field, "key_field")
           index_name = klass.index_name.to_s
           raise InvalidIndexDefinition, "index_name must be present" if index_name.strip.empty?
 
@@ -116,12 +110,10 @@ module ParadeDB
 
           index_options = normalize_index_options(klass.index_options)
 
-          validate_key_field_shape!(key_field.to_s, entries)
           validate_query_key_collisions!(entries)
 
           Compiled.new(
             table_name: table_name,
-            key_field: key_field,
             index_name: index_name,
             entries: entries,
             index_options: index_options,
@@ -255,14 +247,29 @@ module ParadeDB
             end
           end
 
-          if normalized.key?(:centroid_ratio)
-            ratio = normalized[:centroid_ratio]
+          if normalized[:search_tokenizer].is_a?(ParadeDB::Tokenizer)
+            normalized[:search_tokenizer] = normalized[:search_tokenizer].render_search
+          end
+          %i[search_tokenizer layer_sizes background_layer_sizes].each do |key|
+            if normalized.key?(key) && (!normalized[key].is_a?(String) || normalized[key].strip.empty?)
+              raise InvalidIndexDefinition, "index_options[#{key.inspect}] must be a non-empty string"
+            end
+          end
+          if normalized.key?(:mutable_segment_rows) && (!normalized[:mutable_segment_rows].is_a?(Integer) || !(0..10000).cover?(normalized[:mutable_segment_rows]))
+            raise InvalidIndexDefinition, "mutable_segment_rows must be an integer between 0 and 10000"
+          end
+          if normalized.key?(:training_sample_ratio)
+            ratio = normalized[:training_sample_ratio]
             unless ratio.is_a?(Numeric) && ratio >= 0.000001 && ratio <= 1.0
               raise InvalidIndexDefinition,
-                    "index_options[:centroid_ratio] must be a Numeric between 0.000001 and 1.0"
+                    "index_options[:training_sample_ratio] must be a Numeric between 0.000001 and 1.0"
             end
           end
 
+          if normalized.key?(:vector_fields) && !normalized[:vector_fields].is_a?(Hash)
+            raise InvalidIndexDefinition, "index_options[:vector_fields] must be a Hash"
+          end
+
           normalized
         end
 
@@ -288,23 +295,7 @@ module ParadeDB
           end
         end
 
-        def validate_key_field_shape!(key_field_name, entries)
-          unless entries.any? { |entry| entry.source == key_field_name }
-            raise InvalidIndexDefinition,
-                  "key_field #{key_field_name.inspect} must be present in fields."
-          end
 
-          first_entry = entries.first
-          unless first_entry.source == key_field_name
-            raise InvalidIndexDefinition,
-                  "key_field #{key_field_name.inspect} must be first in fields."
-          end
-
-          return if first_entry.tokenizer.nil?
-
-          raise InvalidIndexDefinition,
-                "key_field #{key_field_name.inspect} must not be tokenized."
-        end
       end
     end
   end

data/lib/parade_db/migration_helpers.rb

@@ -25,11 +25,10 @@ module ParadeDB
       remember_schema_index_reference(resolved)
     end
 
-    def add_paradedb_index(table, fields:, key_field:, name: nil, index_options: nil, where: nil, if_not_exists: false, concurrently: false)
+    def add_paradedb_index(table, fields:, name: nil, index_options: nil, where: nil, if_not_exists: false, concurrently: false)
       ensure_postgresql_adapter!
       anonymous = Class.new(ParadeDB::Index)
       anonymous.table_name = table
-      anonymous.key_field = key_field
       anonymous.index_name = name unless name.nil?
       anonymous.fields = fields
       anonymous.index_options = index_options unless index_options.nil?
@@ -86,26 +85,30 @@ module ParadeDB
       prefix = if_not_exists ? "IF NOT EXISTS " : ""
       fields_sql = compiled.entries.map { |entry| paradedb_entry_sql(entry) }.join(", ")
       with_options_sql = paradedb_with_options_sql(compiled)
+      with_clause = with_options_sql.empty? ? "" : "\nWITH (#{with_options_sql})"
       where_sql = compiled.where ? "\nWHERE #{compiled.where}" : ""
 
       <<~SQL.strip.gsub(/\s+/, " ")
         CREATE INDEX#{modifier} #{prefix}#{quote_table_name(compiled.index_name)} ON #{quote_table_name(compiled.table_name)}
-        USING paradedb (#{fields_sql})
-        WITH (#{with_options_sql})#{where_sql}
+        USING paradedb (#{fields_sql})#{with_clause}#{where_sql}
       SQL
     end
 
     def paradedb_with_options_sql(compiled)
       options = []
-      options << "key_field=#{quote(compiled.key_field.to_s)}"
-
       compiled.index_options.each do |key, value|
         name = key.to_sym
         case name
-        when :target_segment_count, :training_samples_per_centroid, :cluster_replication
+        when :target_segment_count, :max_leaf_size, :mutable_segment_rows
           options << "#{name}=#{Integer(value)}"
-        when :centroid_ratio
-          options << "centroid_ratio=#{Float(value)}"
+        when :partition_by
+          options << "#{name}=#{quote(value.join(","))}"
+        when :search_tokenizer, :layer_sizes, :background_layer_sizes
+          options << "#{name}=#{quote(value.to_s)}"
+        when :vector_fields
+          options << "vector_fields=#{quote(JSON.generate(value))}"
+        when :training_sample_ratio
+          options << "training_sample_ratio=#{Float(value)}"
         else
           raise ParadeDB::InvalidIndexDefinition, "unsupported index option #{key.inspect}"
         end
@@ -322,12 +325,11 @@ module ParadeDB
       table = row["table_name"]
       name = row["index_name"]
 
-      key_field = extract_paradedb_key_field(indexdef)
       index_options = extract_paradedb_index_options(row["reloptions"])
       fields_sql = extract_paradedb_fields_sql(indexdef)
       where = normalize_paradedb_where_clause(row["where_clause"])
 
-      if key_field && fields_sql
+      if fields_sql
         field_sqls = split_paradedb_top_level(fields_sql).map(&:strip)
         parsed = field_sqls.map { |f| paradedb_parse_column_entry(f) }
 
@@ -350,9 +352,8 @@ module ParadeDB
         end
 
         statement = "add_paradedb_index #{table.to_sym.inspect}, " \
-          "fields: { #{fields_pairs.join(', ')} }, " \
-          "key_field: #{key_field.to_sym.inspect}, " \
-          "name: #{name.inspect}"
+          "fields: { #{fields_pairs.join(', ')} }, "
+        statement += "name: #{name.inspect}"
         unless index_options.empty?
           statement += ", index_options: #{ruby_hash_literal(index_options)}"
         end
@@ -363,28 +364,24 @@ module ParadeDB
       end
     end
 
-    def extract_paradedb_key_field(indexdef)
-      quoted = indexdef.match(/WITH\s*\([^)]*key_field\s*=\s*'((?:[^']|'')*)'/i)
-      return quoted[1].gsub("''", "'") if quoted
-
-      unquoted = indexdef.match(/WITH\s*\([^)]*key_field\s*=\s*([a-zA-Z_][a-zA-Z0-9_]*)/i)
-      return unquoted[1] if unquoted
-
-      nil
-    end
-
     def extract_paradedb_index_options(reloptions)
       paradedb_reloption_entries(reloptions).each_with_object({}) do |entry, options|
         key, separator, value = entry.to_s.partition("=")
         next if separator.empty?
 
         case key
-        when "target_segment_count", "training_samples_per_centroid", "cluster_replication"
+        when "target_segment_count", "max_leaf_size", "mutable_segment_rows"
           parsed = Integer(value, 10, exception: false)
           options[key.to_sym] = parsed if parsed
-        when "centroid_ratio"
+        when "partition_by"
+          options[key.to_sym] = value.split(",")
+        when "search_tokenizer", "layer_sizes", "background_layer_sizes"
+          options[key.to_sym] = value
+        when "vector_fields"
+          options[:vector_fields] = JSON.parse(value)
+        when "training_sample_ratio"
           parsed = Float(value, exception: false)
-          options[:centroid_ratio] = parsed if parsed
+          options[:training_sample_ratio] = parsed if parsed
         end
       end
     end
@@ -868,11 +865,10 @@ if defined?(ActiveRecord::Migration)
         connection.replace_paradedb_index(index_klass)
       end
 
-      def add_paradedb_index(table, fields:, key_field:, name: nil, index_options: nil, where: nil, if_not_exists: false, concurrently: false)
+      def add_paradedb_index(table, fields:, name: nil, index_options: nil, where: nil, if_not_exists: false, concurrently: false)
         connection.add_paradedb_index(
           table,
           fields: fields,
-          key_field: key_field,
           name: name,
           index_options: index_options,
           where: where,

data/lib/parade_db/model.rb

@@ -11,17 +11,18 @@ module ParadeDB
       :paradedb_search,
       :more_like_this,
       :nearest,
+      :l2_distance,
+      :cosine_distance,
+      :inner_product,
       :with_facets,
       :facets,
       :with_agg,
       :facets_agg,
       :aggregate_by,
-      :paradedb_arel,
       :paradedb_index,
       :paradedb_index_class,
       :paradedb_index_classes,
       :paradedb_indexed_fields,
-      :paradedb_key_field,
       :paradedb_index_name,
       :paradedb_validate_index!
     ].freeze
@@ -74,6 +75,21 @@ module ParadeDB
         all.extending(SearchMethods).nearest(column, vector, metric: metric)
       end
 
+      def l2_distance(column, vector)
+        ensure_postgres!
+        QueryBuilder.new(table_name).vector_distance(column, vector, metric: :l2)
+      end
+
+      def cosine_distance(column, vector)
+        ensure_postgres!
+        QueryBuilder.new(table_name).vector_distance(column, vector, metric: :cosine)
+      end
+
+      def inner_product(column, vector)
+        ensure_postgres!
+        QueryBuilder.new(table_name).vector_distance(column, vector, metric: :ip)
+      end
+
       def with_facets(*fields, **opts)
         ensure_postgres!
         paradedb_validate_index!
@@ -108,11 +124,6 @@ module ParadeDB
         )
       end
 
-      def paradedb_arel
-        ensure_postgres!
-        @paradedb_arel ||= ParadeDB::Arel::Builder.new(table_name)
-      end
-
       def paradedb_index(index_class)
         @paradedb_explicit_index_classes ||= []
         @paradedb_explicit_index_classes << index_class unless @paradedb_explicit_index_classes.include?(index_class)
@@ -143,11 +154,6 @@ module ParadeDB
         definition.entries.map(&:query_key).uniq
       end
 
-      def paradedb_key_field
-        definition = paradedb_index_definition
-        definition&.key_field
-      end
-
       def paradedb_index_name
         definition = paradedb_index_definition
         definition&.index_name