huginn_datatable 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7014d31503c76a5637c2bd15b82b8cf2be1c173ef11575a9325ec8457d7c65e
-  data.tar.gz: 175542cecf2d1378d0fa571ef538c0f2cccf24d6acab94bb3e0b398e97926261
+  metadata.gz: '05719914312baa1225e26059bd5154312ee5df8bc369df6f5f9676d423ed9d0e'
+  data.tar.gz: b876f81b7add7781a4bd6b7424e3674f251c09ecfe38e0a70e8f891bb2286c76
 SHA512:
-  metadata.gz: 951dcb3aeb617bc98b23fc8e883e0fa06d572ff312e0888171b17a26b70454eddbf84972bc6dfd91589a3788ac188266d1282d9122f53522923094ebdec0017c
-  data.tar.gz: 21ed148247e3e9d3a9cff2682d4d19c15c4bdf7806fd0222c4018f829a98fde7f52720e8219e2caaaa929d8c778f5ccc6b7933de9b2245bc6b597c89f27a7745
+  metadata.gz: bed2c0bc55d70a6ceaa57a6a84fb264360df75cbab4f42a2a82031073fdd0f15778b1681afcdc35aba31a478e4e8c18a6acfc960b725a1018306211845e72c72
+  data.tar.gz: 8f58d9e3fec2d2a38350dc010f9b68d6ab60449e27338291dfae8ae7bcaba2b96cbb64f945067487c1ed97889c6642bbb451dfde21644b0170e708ae109aa30a

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ### Unreleased
 
+#### 0.2.1
+
+- Association-scoped `search` now matches through **primary-key semi-join subqueries** (`pk IN (SELECT DISTINCT pk FROM <base> JOIN <chain> WHERE <fuzzy>)`) instead of `left_joins` — one subquery per distinct association chain, combined with OR. The base relation never joins, so the count is a plain `COUNT(*)`.
+
 #### 0.2.0
 
 - **Breaking:** `:pg_trgm` search now uses the PostgreSQL `%` operator (`UNACCENT(col) % UNACCENT('term')`), driven by the **indexable** operator instead of a bare `similarity()` comparison. A `gin_trgm_ops` GIN index on `UNACCENT(col)` is used when present (BitmapOr over the same index with the ILIKE branch); without it, results stay correct via sequential scan.

data/README.md

@@ -18,7 +18,7 @@ Huginn is a lightweight query layer for Rails that turns a raw datatable request
 ## Highlights
 
 - **Two-phase execution** — association filters/orders/range become reflection-secured subqueries, then a lean count and `preload` **only on the paginated subset**.
-- **Lean counts** — `COUNT(DISTINCT pk)` through a stripped relation; no JOIN materialization.
+- **Lean counts** — the base relation never joins (`COUNT(*)` over a stripped relation); association matches run as pk subqueries instead.
 - **SQL injection safe ordering/filtering** — every column reference is resolved through Arel reflection, never string-interpolated.
 - **Accent/typo tolerant search** — `pg_trgm` similarity (`%` operator) OR `unaccent+ILIKE`, with a configurable fallback chain; uses a `gin_trgm_ops` GIN index when one exists.
 - **Rails conventions** — works with `ActionController::Parameters`, Railtie auto-includes both concerns (toggleable), zero boilerplate.
@@ -129,7 +129,7 @@ Any `column` **or** `association.column` reference is validated and mapped to it
 Plano.datatable({ orders: [{ "operadora.pessoa.nome" => "asc" }] }, allowed_paths: [{ operadora: :pessoa }])
 ```
 
-> Association filters/range and ordering use reflection-resolved subqueries (see the "allowlist of associations" section below). The main relation stays singular and the count is `COUNT(DISTINCT pk)`.
+> Association filters/range, ordering and search use reflection-resolved subqueries (see the "allowlist of associations" section below). The base relation stays singular and join-free, so the count is a plain `COUNT(*)`.
 
 ## Association allowlist (`allowed_paths`)
 
@@ -185,7 +185,7 @@ class Person < ApplicationRecord
   searchable_columns :name, company: [:name, :cnpj]
 end
 
-Person.search("globex")                            # matches company.name via a left_join
+Person.search("globex")                            # matches company.name via a pk subquery
 Person.search("kayky", distinct: false)            # disable the implicit DISTINCT
 ```
 
@@ -235,7 +235,7 @@ Notes:
 
 ```
 phase 1  build the relation          subqueries (pk IN … / ORDER BY (SELECT …)) + search + filters + order   (no data in memory)
-phase 2  count                       SELECT COUNT(DISTINCT "<pk column>") ... (subquery, pk-indexed)
+phase 2  count                       SELECT COUNT(*) ... (base relation is join-free)
           paginate                   offset / limit
           preload                    SELECT ... WHERE id IN (subset)        (2nd lightweight query)
 ```
@@ -257,7 +257,7 @@ lib/huginn/datatable/filter_normalizer.rb  functional param normalization
 lib/huginn/datatable/paginator.rb    lean count, pagination, isolated preload
 lib/huginn/searchable.rb            Huginn::Searchable (aggregator)
 lib/huginn/searchable/searchable.rb the search Concern + DSL
-lib/huginn/searchable/query.rb      tolerant search builder (joins + OR)
+lib/huginn/searchable/query.rb      tolerant search builder (subqueries + OR)
 lib/huginn/searchable/fuzzy.rb      pg_trgm / unaccent / simple predicates
 lib/generators/...                  `huginn:trigram_indexes` (GIN index migrations)
 ```

data/README.pt-BR.md

@@ -18,7 +18,7 @@ O Huginn é uma camada de consulta leve para Rails que transforma uma requisiç
 ## Destaques
 
 - **Execução em duas fases** — filtros/orders/ranges de associação se tornam subqueries resolvidas por reflexão, e o `preload` é feito **somente no subconjunto paginado**.
-- **Counts enxutos** — `COUNT(DISTINCT pk)` através de uma relation restrita, sem materialização de JOINs.
+- **Counts enxutos** — a relation base nunca faz join (`COUNT(*)` sobre uma relation restrita); as buscas de associação acontecem via subqueries no pk.
 - **Ordenação/filtro seguros contra SQL injection** — toda referência de coluna é resolvida via reflexão do Arel, nunca interpolada como string.
 - **Busca tolerante a acentos/typos** — similaridade `pg_trgm` (operador `%`) OU `unaccent+ILIKE`, com cadeia de fallback configurável; usa índice GIN `gin_trgm_ops` quando existente.
 - **Convenções do Rails** — funciona com `ActionController::Parameters`, Railtie inclui ambos os concerns automaticamente (desligável), zero boilerplate.
@@ -129,7 +129,7 @@ Qualquer referência `column` **ou** `associacao.column` é validada e mapeada p
 Plano.datatable({ orders: [{ "operadora.pessoa.nome" => "asc" }] }, allowed_paths: [{ operadora: :pessoa }])
 ```
 
-> Filtros/ranges e order de associação usam subqueries resolvidas por reflexão (veja a seção "Allowlist de associações" abaixo). A relation principal permanece única e o count é `COUNT(DISTINCT pk)`.
+> Filtros/ranges, order e busca de associação usam subqueries resolvidas por reflexão (veja a seção "Allowlist de associações" abaixo). A relation base permanece única e sem joins, então o count é um `COUNT(*)` simples.
 
 ## Allowlist de associações (`allowed_paths`)
 
@@ -185,7 +185,7 @@ class Person < ApplicationRecord
   searchable_columns :name, company: [:name, :cnpj]
 end
 
-Person.search("globex")                            # encontra company.name via left_join
+Person.search("globex")                            # encontra company.name via subquery no pk
 Person.search("kayky", distinct: false)            # desativa o DISTINCT implícito
 ```
 
@@ -235,7 +235,7 @@ Observações:
 
 ```
 fase 1  construir a relation      subqueries (pk IN … / ORDER BY (SELECT …)) + search + filters + order   (sem dados em memória)
-fase 2  count                     SELECT COUNT(DISTINCT "<pk>") ... (subquery, indexada por pk)
+fase 2  count                     SELECT COUNT(*) ... (relation base sem joins)
         paginate                  offset / limit
         preload                   SELECT ... WHERE id IN (subset)        (2ª query leve)
 ```
@@ -257,7 +257,7 @@ lib/huginn/datatable/filter_normalizer.rb  normalização funcional de params
 lib/huginn/datatable/paginator.rb  count enxuto, paginação, preload isolado
 lib/huginn/searchable.rb            Huginn::Searchable (agregador)
 lib/huginn/searchable/searchable.rb o Concern do search + DSL
-lib/huginn/searchable/query.rb      construtor de busca tolerante (joins + OR)
+lib/huginn/searchable/query.rb      construtor de busca tolerante (subqueries + OR)
 lib/huginn/searchable/fuzzy.rb      predicados pg_trgm / unaccent / simple
 lib/generators/...                  gerador `huginn:trigram_indexes` (migrations de índices GIN)
 ```

data/lib/huginn/datatable/paginator.rb

@@ -10,10 +10,9 @@ module Huginn
     #   2. count lean, paginate with Pagy, then preload associations only
     #      on the small paginated subset.
     #
-    # The count runs against a stripped relation (no select/includes/order/
-    # offset/limit) selecting only the primary key with DISTINCT, so that
-    # PostgreSQL answers it through the PK index as a subquery instead of a
-    # massive COUNT(DISTINCT ...) over the joins.
+    # The base relation never carries joins (association filters, ranges,
+    # orders and the search are all resolved through primary-key subqueries),
+    # so the count stays a plain COUNT(*) over the stripped relation.
     class Paginator
       attr_reader :relation, :params, :includes
 
@@ -77,10 +76,7 @@ module Huginn
       end
 
       def total_count
-        stripped = relation.except(:select, :includes, :order, :offset, :limit)
-        return stripped.count unless stripped.left_outer_joins_values.any? || stripped.joins_values.any?
-
-        stripped.select(stripped.arel_table[stripped.primary_key]).distinct.count
+        relation.except(:select, :includes, :order, :offset, :limit).count
       end
 
       def config

data/lib/huginn/searchable/query.rb

@@ -1,13 +1,23 @@
 # frozen_string_literal: true
 
+require_relative "../datatable/association_path"
+
 module Huginn
   module Searchable
+    AssociationPath = Datatable::AssociationPath unless const_defined?(:AssociationPath)
     # Builds a tolerant full-text search relation over a model's searchable
-    # columns, optionally crossing associations through left_joins.
+    # columns.
+    #
+    # Columns are split in two groups following the datatable pattern:
     #
-    # All matched columns are fused into a single Arel OR predicate, so the
-    # whole search stays one query regardless of how many columns (or
-    # associations) are involved.
+    #   * the model's own columns  -> direct fuzzy predicates on the base WHERE
+    #   * association columns      -> semi-join subqueries on the primary key
+    #                                  pk IN (SELECT DISTINCT pk FROM base
+    #                                       JOIN <chain> ... WHERE <fuzzy>)
+    #
+    # The base relation never carries joins, so every match group stays one
+    # query and the count remains a plain COUNT(*). Multiple association
+    # chains produce one subquery each, combined with OR.
     class Query
       def self.call(model, value, options = {})
         new(model, value, options).call
@@ -25,45 +35,65 @@ module Huginn
         return apply_distinct(relation) if @value.strip.empty?
 
         resolution = resolve_columns
-        return apply_distinct(relation) if resolution.fetch(:attrs).empty?
+        predicates = fuzzy_predicates(resolution.fetch(:own))
+        resolution.fetch(:associations).each do |chain, attrs|
+          subquery = association_subquery(chain, attrs)
+          predicates << arel_table[primary_key].in(subquery.arel) if subquery
+        end
 
-        joins = resolution.fetch(:joins)
-        relation = relation.left_joins(*joins) if joins.any?
+        return apply_distinct(relation) if predicates.empty?
 
-        predicate = resolution.fetch(:attrs).map { |attr| fuzzy_predicate(attr) }.reduce(&:or)
-        apply_distinct(relation.where(predicate))
+        apply_distinct(relation.where(predicates.reduce(&:or)))
       end
 
       private
 
+      def fuzzy_predicates(attrs)
+        attrs.map { |attr| fuzzy_predicate(attr) }
+      end
+
       def resolve_columns
         columns = @model.searchable_columns_config_resolved
-        joins = []
-        attrs = []
+        own = []
+        associations = Hash.new { |hash, key| hash[key] = [] }
 
         Array(columns[:columns]).map(&:to_s).reject(&:blank?).each do |field|
           if field.include?(".")
-            name, col = field.split(".", 2)
-            push_association(joins, attrs, name, col)
+            chain, column = field.split(".", 2)
+            push_association(associations, chain, column)
           else
-            attrs << @model.arel_table[field] if @model.columns_hash.key?(field)
+            own << @model.arel_table[field] if @model.columns_hash.key?(field)
           end
         end
 
         columns[:associations].each do |name, cols|
-          Array(cols).each { |col| push_association(joins, attrs, name.to_s, col.to_s) }
+          Array(cols).each { |column| push_association(associations, name.to_s, column.to_s) }
         end
 
-        { joins: joins.uniq, attrs: attrs }
+        { own: own, associations: associations }
+      end
+
+      def push_association(groups, chain, column)
+        path = AssociationPath.call(@model, "#{chain}.#{column}")
+        return unless path.valid?
+        return unless path.target_klass.columns_hash.key?(path.column)
+
+        groups[path.association_names] << path.target_table[path.column]
       end
 
-      def push_association(joins, attrs, name, col)
-        association = @model.reflect_on_association(name.to_sym)
-        return unless association
+      # Semi-join subquery over the base table: DISTINCT pk while joining the
+      # association chain of the group and applying the fuzzy predicates on the
+      # target columns. Mirrors datatable's association_ids_subquery.
+      def association_subquery(chain, attrs)
+        return nil if chain.empty?
 
-        table = association.klass.arel_table
-        attrs << table[col] if association.klass.columns_hash.key?(col)
-        joins << name.to_sym unless joins.include?(name.to_sym)
+        spec = AssociationPath.join_spec_for(chain.map(&:to_sym))
+        base = @model.all.except(:select, :order, :offset, :limit)
+                        .select(arel_table[primary_key])
+                        .distinct
+
+        predicate = fuzzy_predicates(attrs).reduce(&:or)
+        base.joins(spec).where(predicate)
       end
 
       def fuzzy_predicate(attr)
@@ -121,6 +151,14 @@ module Huginn
         @model.connection.adapter_name.downcase.include?("postgres")
       end
 
+      def arel_table
+        @model.arel_table
+      end
+
+      def primary_key
+        @model.primary_key
+      end
+
       def apply_distinct(relation)
         @distinct ? relation.distinct : relation
       end

data/lib/huginn/searchable/searchable.rb

@@ -17,8 +17,8 @@ module Huginn
       #
       # When nothing is declared, every :string/:text column of the model is
       # searched automatically. Columns may be association-scoped ("person.name")
-      # or declared via keyword arguments; scoped columns are reached through a
-      # left_join.
+      # or declared via keyword arguments; scoped columns are resolved through
+      # semi-join subqueries on the primary key (no joins on the base relation).
       def searchable_columns(*columns, **associations)
         self.searchable_columns_config = {
           columns: columns.flatten.compact.map(&:to_s),

data/lib/huginn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Huginn
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: huginn_datatable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Kayky Marcelo