full_search 0.4.8 → 0.4.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f50c2f24f4b4929d3da0744d93e33a0b6c5a6ba3743c4542612c6e1007687691
-  data.tar.gz: d497857811078992322ad4cd081e41aa476878c0950b71a2ec5bcd7a76ff8db2
+  metadata.gz: b21fb40775574ba4e404c2409fb2b4a4a57095baeb2f4867ca52812391d31348
+  data.tar.gz: baf95666180a4702197d41deb90ea31a423c5f33a3aa90dc52d3709d5df44a3a
 SHA512:
-  metadata.gz: bf77188446fed43a0e9f69826f85ced628f5960d493cbd96d721730e9fd9d8c92ffe5c58412aee47e81feb01adca00e2e7b7641f85ea01fe2c98fcaaca05b5f1
-  data.tar.gz: 89e0b8dc7ee2b44391deb5c339e2b048c836431a5997ab19c281285b1fef79fcfe5ad4fea02793a672643899e08e5276a12dbadacf51cb3411853d389c6fbbf7
+  metadata.gz: a52f22fffe5a0751a1be3178e65d8ea51c08b789e8240017d9f036e8d407ff68c45deffd7dc99e1e3a5c68813448eab82f06ee38b103838f24dbb42df182485c
+  data.tar.gz: 4b791aea84de3a56fda5674e4a3e74af7cec5d53ca4e24d241c54c9f368bbc9c579cc8a22a62c46e4956f5a2892515a6be0b0d4f3aab77cb4cc5d34e55145fbd

data/README.md

@@ -150,7 +150,9 @@ FTS indexes are SQLite virtual tables (`customers_fts`, `vehicles_fts`, etc.) th
 These two operations are often confused:
 
 - **Rebuild** (`full_search:rebuild` / `Customer.rebuild!`) — drops and recreates the FTS virtual table. Needed when the DSL changes (fields added/removed, tokenizer changed, etc.). The table is re-created from scratch, backfilled, triggers re-installed, and the index is optimized.
-- **Reindex** (`Customer.reindex!` / `FullSearch::Index.reindex_source_fields!`) — updates existing FTS rows with fresh values from computed `source:` fields only. The table structure is untouched. Database triggers cover regular column changes automatically; only Ruby-evaluated `source:` blocks need an explicit reindex.
+- **Reindex** (`Customer.reindex!` / `Customer.reindex_ids([ids])` / `FullSearch::Index.reindex_source_fields!`) — updates existing FTS rows with fresh values from computed `source:` fields only. The table structure is untouched. Database triggers cover regular column changes automatically, and since v0.4.9 they **preserve** existing `source:` field values rather than wiping them to `''` on UPDATE. Only Ruby-evaluated `source:` blocks need an explicit reindex.
+
+  **Important:** raw SQL operations that bypass Rails callbacks (`update_all`, `update_column`, `insert_all`, `upsert_all`, `counter_cache`, `touch`) will not run the `after_save_commit` reindex hook. Use `Model.reindex_ids(ids)` after a callback-free `update_all` that changes data backing a `source:` field, or `Model.reindex!` after a bulk insert, to keep the FTS source fields in sync.
 
 ### Setup lifecycle
 
@@ -235,6 +237,21 @@ end
 
 When disabled, you must run `bin/rails full_search:prepare` after every `db:schema:load` to recreate the indexes.
 
+`full_search` also ensures FTS tables exist before `db:schema:dump` reads the database and after `db:schema:load` finishes, so virtual tables are never silently dropped from `schema.rb` when models are registered but their tables haven't been created yet (e.g. development with `eager_load = false`). These hooks are gated by two config options, both on by default:
+
+```ruby
+FullSearch.configure do |config|
+  # Run full_search:prepare before db:schema:dump so every registered
+  # FTS table is present in sqlite_master when the dumper reads it.
+  config.auto_prepare_on_schema_dump = true
+
+  # Create any FTS tables missing from schema.rb after db:schema:load.
+  config.auto_prepare_after_schema_load = true
+end
+```
+
+Set either to `false` if you prefer to run `bin/rails full_search:prepare` manually.
+
 ### Rake tasks
 
 | Task | Description |

data/lib/full_search/config.rb

@@ -5,7 +5,8 @@ module FullSearch
     attr_accessor :auto_rebuild_schema, :stale_query_behavior, :lock_rebuilds,
       :default_async_reindex, :default_async_source_reindex,
       :default_tokenizer, :auto_rebuild_on_stale_query, :min_like_prefix_length,
-      :dump_schema_virtual_tables, :auto_rebuild_missing_tables
+      :dump_schema_virtual_tables, :auto_rebuild_missing_tables,
+      :auto_prepare_on_schema_dump, :auto_prepare_after_schema_load
 
     def initialize
       @auto_rebuild_schema = false
@@ -18,6 +19,8 @@ module FullSearch
       @min_like_prefix_length = FullSearch::Constants::DEFAULT_MIN_LIKE_PREFIX_LENGTH
       @dump_schema_virtual_tables = true
       @auto_rebuild_missing_tables = false
+      @auto_prepare_on_schema_dump = true
+      @auto_prepare_after_schema_load = true
     end
   end
 

data/lib/full_search/index.rb

@@ -452,24 +452,27 @@ module FullSearch
 
         when_clause = SoftDelete.active_update_clause(model)
 
+        update_assignments = update_assignments_sql(cols)
+
         if dsl.conditional_index?
           select_parts = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
           <<~SQL
             CREATE TRIGGER #{qt(trigger_names(model)[2])} AFTER UPDATE ON #{qt(model.table_name)} #{when_clause}
             BEGIN
-              DELETE FROM #{fts_table} WHERE rowid = old.id;
+              DELETE FROM #{fts_table} WHERE rowid = old.id
+                AND NOT EXISTS (SELECT 1 FROM #{tbl} WHERE #{tbl}.id = old.id AND (#{dsl.index_if_sql}));
+              UPDATE #{fts_table} SET #{update_assignments} WHERE rowid = new.id
+                AND EXISTS (SELECT 1 FROM #{tbl} WHERE #{tbl}.id = new.id AND (#{dsl.index_if_sql}));
               INSERT INTO #{fts_table}(rowid, #{cols_str})
-              SELECT new.id, #{select_parts} FROM #{tbl} WHERE #{tbl}.id = new.id AND (#{dsl.index_if_sql});
+                SELECT new.id, #{select_parts} FROM #{tbl} WHERE #{tbl}.id = new.id AND (#{dsl.index_if_sql})
+                  AND NOT EXISTS (SELECT 1 FROM #{fts_table} WHERE #{fts_table}.rowid = new.id);
             END;
           SQL
         else
-          values = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
           <<~SQL
             CREATE TRIGGER #{qt(trigger_names(model)[2])} AFTER UPDATE ON #{qt(model.table_name)} #{when_clause}
             BEGIN
-              DELETE FROM #{fts_table} WHERE rowid = old.id;
-              INSERT INTO #{fts_table}(rowid, #{cols_str})
-              VALUES (new.id, #{values});
+              UPDATE #{fts_table} SET #{update_assignments} WHERE rowid = new.id;
             END;
           SQL
         end
@@ -562,24 +565,27 @@ module FullSearch
 
         when_clause = SoftDelete.active_update_clause(model)
 
+        update_assignments = update_assignments_sql(cols)
+
         if dsl.conditional_index?
           select_parts = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
           <<~SQL
             CREATE TRIGGER #{qt(trigram_trigger_names(model)[2])} AFTER UPDATE ON #{qt(model.table_name)} #{when_clause}
             BEGIN
-              DELETE FROM #{trigram_table} WHERE rowid = old.id;
+              DELETE FROM #{trigram_table} WHERE rowid = old.id
+                AND NOT EXISTS (SELECT 1 FROM #{tbl} WHERE #{tbl}.id = old.id AND (#{dsl.index_if_sql}));
+              UPDATE #{trigram_table} SET #{update_assignments} WHERE rowid = new.id
+                AND EXISTS (SELECT 1 FROM #{tbl} WHERE #{tbl}.id = new.id AND (#{dsl.index_if_sql}));
               INSERT INTO #{trigram_table}(rowid, #{cols_str})
-              SELECT new.id, #{select_parts} FROM #{tbl} WHERE #{tbl}.id = new.id AND (#{dsl.index_if_sql});
+                SELECT new.id, #{select_parts} FROM #{tbl} WHERE #{tbl}.id = new.id AND (#{dsl.index_if_sql})
+                  AND NOT EXISTS (SELECT 1 FROM #{trigram_table} WHERE #{trigram_table}.rowid = new.id);
             END;
           SQL
         else
-          values = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
           <<~SQL
             CREATE TRIGGER #{qt(trigram_trigger_names(model)[2])} AFTER UPDATE ON #{qt(model.table_name)} #{when_clause}
             BEGIN
-              DELETE FROM #{trigram_table} WHERE rowid = old.id;
-              INSERT INTO #{trigram_table}(rowid, #{cols_str})
-              VALUES (new.id, #{values});
+              UPDATE #{trigram_table} SET #{update_assignments} WHERE rowid = new.id;
             END;
           SQL
         end
@@ -604,6 +610,28 @@ module FullSearch
         end
       end
 
+      # Builds `col = value` assignments for the AFTER UPDATE trigger. Source
+      # fields are deliberately excluded so a raw SQL UPDATE (e.g. a
+      # counter_cache or touch) does not wipe the previously computed source
+      # value back to an empty string. Source fields are refreshed later by the
+      # after_save_commit reindex callback on normal Rails saves.
+      #
+      # When every column is a source field (nothing to update), emit a valid
+      # no-op assignment so the generated trigger SQL stays syntactically valid.
+      def update_assignments_sql(cols)
+        assignments = cols.filter_map do |col|
+          if col.respond_to?(:unindexed?) && col.name == "indexed"
+            "#{qc(col.name)} = '1'"
+          elsif col.respond_to?(:source) && col.source
+            nil
+          else
+            "#{qc(column_name(col))} = new.#{qc(column_name(col))}"
+          end
+        end
+        assignments << "#{qc(column_name(cols.first))} = #{qc(column_name(cols.first))}" if assignments.empty?
+        assignments.join(", ")
+      end
+
       # NOTE: This lock prevents concurrent rebuilds within the same process/connection only.
       # For multi-process or multi-host deployments, run full_search:rebuild from a single
       # deployment step. See README.

data/lib/full_search/model.rb

@@ -40,6 +40,19 @@ module FullSearch
         FullSearch::Index.reindex_source_fields!(self)
       end
 
+      # Re-evaluates source: fields for a specific set of records and updates
+      # the FTS table in place. Use after bulk operations that bypass model
+      # callbacks (e.g. `update_all`, `insert_all`, `upsert_all`, `update_column`)
+      # so the source fields don't drift out of sync with the underlying rows.
+      def reindex_ids(ids)
+        source_ids = ids.to_a.map(&:to_i).reject(&:zero?)
+        return if source_ids.empty?
+
+        where(id: source_ids).find_each(batch_size: 500) do |record|
+          FullSearch::Callbacks.reindex_record!(record)
+        end
+      end
+
       def bulk_import(&block)
         FullSearch.bulk_import(self, &block)
       end
@@ -75,6 +88,13 @@ module FullSearch
 
         FullSearch::Model.evaluate_source(self, field)
       end
+
+      # Re-evaluates this record's source: fields and writes them to the FTS
+      # table immediately (synchronously). Use after a callback-free mutation
+      # (update_column, update_all, counter_cache/touch) to refresh the index.
+      def reindex_source_fields!
+        FullSearch::Callbacks.reindex_record!(self)
+      end
     end
   end
 end

data/lib/full_search/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FullSearch
-  VERSION = "0.4.8"
+  VERSION = "0.4.10"
 end

data/lib/generators/full_search/install/templates/full_search.rb

@@ -16,6 +16,17 @@ FullSearch.configure do |config|
   # Bulk imports should use FullSearch.bulk_import(Model) { ... } to defer reindexing.
   config.default_async_source_reindex = true
 
+  # Ensure FTS tables exist before db:schema:dump reads the database, so
+  # virtual tables are never silently dropped from schema.rb. Set to false
+  # if you prefer to run `bin/rails full_search:prepare` manually before
+  # dumping the schema.
+  config.auto_prepare_on_schema_dump = true
+
+  # Create any FTS tables missing from schema.rb after db:schema:load.
+  # Set to false if you prefer to run `bin/rails full_search:prepare`
+  # manually after loading the schema.
+  config.auto_prepare_after_schema_load = true
+
   # Uncomment to exclude full_search virtual tables from db/schema.rb.
   # When false, you must run `bin/rails full_search:prepare` after db:schema:load.
   # config.dump_schema_virtual_tables = false

data/lib/tasks/full_search.rake

@@ -140,4 +140,43 @@ namespace :full_search do
       puts "[OK] All full_search indexes are healthy"
     end
   end
+
+  # Internal: ensure FTS tables exist before db:schema:dump reads
+  # sqlite_master. Gated by auto_prepare_on_schema_dump so apps that
+  # prefer manual control can opt out.
+  task auto_prepare_before_dump: :environment do
+    next unless FullSearch.config.auto_prepare_on_schema_dump
+
+    Rails.application.eager_load!
+    FullSearch.setup!
+  end
+
+  # Internal: create any FTS tables missing from schema.rb after
+  # db:schema:load. Gated by auto_prepare_after_schema_load.
+  task auto_prepare_after_load: :environment do
+    next unless FullSearch.config.auto_prepare_after_schema_load
+
+    Rails.application.eager_load!
+    FullSearch.setup!
+  end
+end
+
+# Ensure FTS tables exist before db:schema:dump reads sqlite_master,
+# so virtual tables aren't silently dropped from schema.rb when models
+# were registered but their FTS tables never got created (e.g. dev with
+# eager_load off, or a fresh db:schema:load against an incomplete dump).
+if Rake::Task.task_defined?("db:schema:dump")
+  Rake::Task["db:schema:dump"].enhance(["full_search:auto_prepare_before_dump"])
+end
+
+# Create any FTS tables missing from schema.rb after db:schema:load.
+# schema.rb may be missing tables if it was dumped with
+# auto_prepare_on_schema_dump = false, or if new searchable models were
+# added since the last dump.
+if Rake::Task.task_defined?("db:schema:load")
+  Rake::Task["db:schema:load"].enhance do
+    next unless FullSearch.config.auto_prepare_after_schema_load
+    Rails.application.eager_load!
+    FullSearch.setup!
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: full_search
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.4.10
 platform: ruby
 authors:
 - Ben D'Angelo
@@ -189,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '2.0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.18
 specification_version: 4
 summary: SQLite FTS5 full-text search for Rails/ActiveRecord
 test_files: []