full_search 0.1.3 → 0.3.0

data/lib/full_search/highlighter.rb

@@ -2,112 +2,207 @@
 
 module FullSearch
   class Highlighter
-    def self.apply!(records, model, query)
-      snippets = build_snippets(model, query)
-      if snippets.values.all?(&:nil?) && records.any?
-        snippets = manual_snippets(records, model, query)
+    class << self
+      def apply!(records, model, query)
+        snippets = build_snippets(model, query)
+        if snippets.values.all?(&:nil?) && records.any?
+          snippets = manual_snippets(records, model, query)
+        end
+        records.each { |record| record.full_search_snippet = snippets[record.id] }
+        records
       end
-      records.each { |record| record.full_search_snippet = snippets[record.id] }
-      records
-    end
 
-    def self.apply_fields!(records, model, query)
-      fields = build_field_snippets(model, query)
-      if fields.empty? && records.any?
-        fields = manual_field_snippets(records, model, query)
+      def apply_fields!(records, model, query)
+        fields = build_field_snippets(model, query)
+        if fields.values.all?(&:empty?) && records.any?
+          fields = manual_field_snippets(records, model, query)
+        end
+        exact_fields = exact_match_field_snippets(records, model, query)
+        records.each do |record|
+          merged = fields[record.id] || {}
+          exact_fields.fetch(record.id, {}).each { |k, v| merged[k] ||= v }
+          record.full_search_highlight_fields = merged
+        end
+        records
       end
-      records.each { |record| record.full_search_highlight_fields = fields[record.id] || {} }
-      records
-    end
 
-    private
+      private
 
-    def self.build_snippets(model, query)
-      rows = highlight_rows(model, query)
-      cols = model.full_search_dsl.fields.map(&:name)
+      def build_snippets(model, query)
+        rows = highlight_rows(model, query)
+        cols = model.full_search_dsl.fields.map(&:name)
 
-      rows.to_h do |row|
-        text = cols.map { |col| row["#{col}_snippet"] }.compact.join(" ").strip
-        [row["rowid"], text.presence]
+        rows.to_h do |row|
+          text = cols.map { |col| row["#{col}_snippet"] }.compact.join(" ").strip
+          [row["rowid"], text.presence]
+        end
       end
-    end
 
-    def self.build_field_snippets(model, query)
-      rows = highlight_rows(model, query)
-      dsl = model.full_search_dsl
-      cols = dsl.fields.map(&:name)
-      open_tag = (dsl.highlight_config || { open_tag: "<mark>" })[:open_tag]
+      def build_field_snippets(model, query)
+        rows = highlight_rows(model, query)
+        dsl = model.full_search_dsl
+        fields = dsl.fields
+        open_tag = (dsl.highlight_config || {open_tag: "<mark>"})[:open_tag]
+
+        rows.to_h do |row|
+          snippets = fields.each_with_object({}) do |field, hash|
+            snippet = row["#{field.name}_snippet"].to_s.strip
+            key = field.as || field.name
+            hash[key] = snippet if snippet.include?(open_tag)
+          end
+          [row["rowid"], snippets]
+        end
+      end
+
+      def compute_max_typos(query, dsl)
+        return nil unless dsl.typo_tolerance?
+        length = query.length
+        min_length = dsl.typo_tolerance_min_term_length.to_i
+        return nil if length < min_length
+        return 2 if length >= 9
+        1
+      end
 
-      rows.to_h do |row|
-        snippets = cols.each_with_object({}) do |col, hash|
-          snippet = row["#{col}_snippet"].to_s.strip
-          hash[col.to_s] = snippet if snippet.include?(open_tag)
+      def manual_snippets(records, model, query)
+        dsl = model.full_search_dsl
+        config = dsl.highlight_config || {open_tag: "<mark>", close_tag: "</mark>"}
+        cols = dsl.fields.map(&:name)
+        max_typos = compute_max_typos(query, dsl)
+
+        records.to_h do |record|
+          text = cols.map { |col| record.full_search_text_for(col).to_s }.join(" ").strip
+          highlighted = manual_highlight(text, query, config, max_typos: max_typos)
+          [record.id, highlighted.presence]
+        end
+      end
+
+      def manual_field_snippets(records, model, query)
+        dsl = model.full_search_dsl
+        config = dsl.highlight_config || {open_tag: "<mark>", close_tag: "</mark>"}
+        fields = dsl.fields
+        max_typos = compute_max_typos(query, dsl)
+
+        records.to_h do |record|
+          snippets = fields.each_with_object({}) do |field, hash|
+            value = record.full_search_text_for(field.name).to_s
+            highlighted = manual_highlight(value, query, config, max_typos: max_typos)
+            key = field.as || field.name
+            hash[key] = highlighted if highlighted.include?(config[:open_tag])
+          end
+          [record.id, snippets]
         end
-        [row["rowid"], snippets]
       end
-    end
 
-    def self.manual_snippets(records, model, query)
-      dsl = model.full_search_dsl
-      config = dsl.highlight_config || { open_tag: "<mark>", close_tag: "</mark>" }
-      cols = dsl.fields.map(&:name)
+      def exact_match_field_snippets(records, model, query)
+        dsl = model.full_search_dsl
+        return {} if dsl.exact_matches.empty?
 
-      records.to_h do |record|
-        text = cols.map { |col| record.public_send(col).to_s }.join(" ").strip
-        highlighted = manual_highlight(text, query, config)
-        [record.id, highlighted.presence]
+        config = dsl.highlight_config || {open_tag: "<mark>", close_tag: "</mark>"}
+        max_typos = compute_max_typos(query, dsl)
+
+        records.to_h do |record|
+          snippets = dsl.exact_matches.each_with_object({}) do |em, hash|
+            value = exact_match_field_value(em, record)
+            highlighted = manual_highlight(value.to_s, query, config, max_typos: max_typos)
+            hash[em.name.to_s] = highlighted if highlighted.include?(config[:open_tag])
+          end
+          [record.id, snippets]
+        end
       end
-    end
 
-    def self.manual_field_snippets(records, model, query)
-      dsl = model.full_search_dsl
-      config = dsl.highlight_config || { open_tag: "<mark>", close_tag: "</mark>" }
-      cols = dsl.fields.map(&:name)
+      def exact_match_field_value(em, record)
+        if em.source
+          record.instance_exec(&em.source)
+        else
+          record.public_send(em.name)
+        end
+      end
+
+      def manual_highlight(text, query, config, max_typos: nil)
+        return text if text.empty? || query.empty?
+
+        open_tag = config[:open_tag]
+        close_tag = config[:close_tag]
+        escaped_query = Regexp.escape(query)
+
+        if text.match?(/#{escaped_query}/i)
+          return text.gsub(/#{escaped_query}/i, "#{open_tag}\\0#{close_tag}")
+        end
 
-      records.to_h do |record|
-        snippets = cols.each_with_object({}) do |col, hash|
-          value = record.public_send(col).to_s
-          highlighted = manual_highlight(value, query, config)
-          hash[col.to_s] = highlighted if highlighted.include?(config[:open_tag])
+        best = best_fuzzy_match(text, query, max_typos: max_typos)
+        if best
+          start_pos, end_pos = best
+          return "#{text[0...start_pos]}#{open_tag}#{text[start_pos...end_pos]}#{close_tag}#{text[end_pos..]}"
         end
-        [record.id, snippets]
+
+        text
       end
-    end
 
-    def self.manual_highlight(text, query, config)
-      return text if text.empty? || query.empty?
-      text.gsub(/#{Regexp.escape(query)}/i, "#{config[:open_tag]}\\0#{config[:close_tag]}")
-    end
+      def best_fuzzy_match(text, query, max_typos: nil)
+        query_len = query.length
+        text_len = text.length
+        return nil if query_len == 0 || text_len == 0
 
-    def self.highlight_rows(model, query)
-      dsl = model.full_search_dsl
-      config = dsl.highlight_config || { open_tag: "<mark>", close_tag: "</mark>" }
-      match_expr = QueryParser.to_match_expression(QueryParser.parse(query))
-      return [] if match_expr.empty?
+        max_typos ||= max_allowed_typos(query_len)
+        return nil if max_typos < 0
 
-      table = FullSearch::Index.fts_table_name(model)
-      cols = dsl.fields.map(&:name)
-      return [] if cols.empty?
+        best_score = max_typos + 1
+        best_range = nil
 
-      highlight_parts = cols.each_with_index.map do |col, idx|
-        "highlight(#{table}, #{idx}, #{quote(config[:open_tag])}, #{quote(config[:close_tag])}) AS #{col}_snippet"
-      end.join(", ")
+        min_window = [1, query_len - max_typos].max
+        max_window = [text_len, query_len + max_typos].min
+        return nil if min_window > max_window
 
-      sql = <<~SQL
-        SELECT rowid, #{highlight_parts}
-        FROM #{table}
-        WHERE #{table} MATCH #{quote(match_expr)}
-      SQL
+        (min_window..max_window).each do |window_len|
+          (0..(text_len - window_len)).each do |start|
+            substr = text[start, window_len]
+            distance = Distance.damerau_levenshtein(query.downcase, substr.downcase)
+            next if distance > max_typos
 
-      connection.execute(sql)
-    end
+            if best_range.nil? || distance < best_score || (distance == best_score && window_len > (best_range[1] - best_range[0]))
+              best_score = distance
+              best_range = [start, start + window_len]
+            end
+          end
+        end
 
-    def self.connection
-      ActiveRecord::Base.connection
-    end
+        best_range
+      end
 
-    def self.quote(value)
-      connection.quote(value)
+      def max_allowed_typos(length)
+        return -1 if length < 3
+        return 2 if length >= 9
+        1
+      end
+
+      def highlight_rows(model, query)
+        dsl = model.full_search_dsl
+        config = dsl.highlight_config || {open_tag: "<mark>", close_tag: "</mark>"}
+        match_expr = QueryParser.to_match_expression(QueryParser.parse(query))
+        return [] if match_expr.empty?
+
+        table = qt(FullSearch::Index.fts_table_name(model))
+        cols = dsl.fields.map(&:name)
+        return [] if cols.empty?
+
+        highlight_parts = cols.each_with_index.map do |col, idx|
+          "highlight(#{table}, #{idx}, #{q(config[:open_tag])}, #{q(config[:close_tag])}) AS #{qc("#{col}_snippet")}"
+        end.join(", ")
+
+        sql = <<~SQL
+          SELECT rowid, #{highlight_parts}
+          FROM #{table}
+          WHERE #{table} MATCH #{q(match_expr)}
+        SQL
+
+        connection.execute(sql)
+      end
+
+      include Quoting
+
+      def connection
+        ActiveRecord::Base.connection
+      end
     end
   end
 end

data/lib/full_search/index.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
-require "ostruct"
+class FilterColumnPlaceholder
+  attr_reader :name
+  def initialize(name:)
+    @name = name.to_s
+  end
+
+  def unindexed?
+    true
+  end
+end
 
 module FullSearch
   class Index
     class << self
       def ensure_table!(model)
-        return unless FullSearch::Index.sqlite?
+        sqlite!(model)
 
         conn = connection
         dsl = model.full_search_dsl
@@ -14,21 +23,31 @@ module FullSearch
 
         create_metadata_table!
 
+        fts_was_created = false
         unless table_exists?(model)
           conn.execute(create_virtual_table_sql(model))
+          fts_was_created = true
         end
 
+        trigram_was_created = false
         if dsl.typo_tolerance? && !trigram_table_exists?(model)
-          FullSearch::Typo.warn_unsupported! unless FullSearch::Typo.supported?
+          FullSearch::Typo.warn_unsupported!(model) unless FullSearch::Typo.supported?(model)
           conn.execute(create_trigram_virtual_table_sql(model))
+          trigram_was_created = true
+        end
+
+        if fts_was_created || trigram_was_created
+          conn.execute(backfill_sql(model)) if fts_was_created
+          conn.execute(backfill_trigram_sql(model)) if trigram_was_created
+          reindex_source_fields!(model) if dsl.fields.any?(&:source)
         end
 
-        ensure_triggers!(model) if model_table_exists?(model)
         store_config_hash!(model)
+        ensure_triggers!(model) if model_table_exists?(model)
       end
 
       def rebuild!(model)
-        return unless FullSearch::Index.sqlite?
+        sqlite!(model)
 
         dsl = model.full_search_dsl
         return unless dsl
@@ -38,29 +57,56 @@ module FullSearch
 
         with_rebuild_lock(model) do
           drop_triggers!(model)
-          conn.execute("DROP TABLE IF EXISTS #{fts_table_name(model)};")
-          conn.execute("DROP TABLE IF EXISTS #{trigram_table_name(model)};")
+          conn.execute("DROP TABLE IF EXISTS #{qt(fts_table_name(model))};")
+          conn.execute("DROP TABLE IF EXISTS #{qt(trigram_table_name(model))};")
           conn.execute(create_virtual_table_sql(model))
           if dsl.typo_tolerance?
-            FullSearch::Typo.warn_unsupported! unless FullSearch::Typo.supported?
+            FullSearch::Typo.warn_unsupported!(model) unless FullSearch::Typo.supported?(model)
             conn.execute(create_trigram_virtual_table_sql(model))
           end
           conn.execute(backfill_sql(model))
           conn.execute(backfill_trigram_sql(model)) if dsl.typo_tolerance?
+          reindex_source_fields!(model) if dsl.fields.any?(&:source)
           create_triggers!(model)
           optimize!(model)
           store_config_hash!(model, rebuilt_at: Time.current)
         end
       end
 
+      def rebuild_if_needed!(model)
+        sqlite!(model)
+
+        dsl = model.full_search_dsl
+        return false unless dsl
+
+        create_metadata_table!
+        ensure_table!(model)
+
+        stored = stored_config_hash(model)
+        if stored && stored == dsl.config_hash
+          false
+        else
+          rebuild!(model)
+          true
+        end
+      end
+
       def optimize!(model)
-        connection.execute("INSERT INTO #{fts_table_name(model)}(#{fts_table_name(model)}) VALUES('optimize');")
+        sqlite!(model)
+        connection.execute("INSERT INTO #{qt(fts_table_name(model))}(#{qt(fts_table_name(model))}) VALUES('optimize');")
+      end
+
+      def reindex_source_fields!(model)
+        model.find_each do |record|
+          FullSearch::Callbacks.reindex_record!(record)
+        end
       end
 
       def drop!(model)
+        sqlite!(model)
         drop_triggers!(model)
-        connection.execute("DROP TABLE IF EXISTS #{fts_table_name(model)};")
-        connection.execute("DROP TABLE IF EXISTS #{trigram_table_name(model)};")
+        connection.execute("DROP TABLE IF EXISTS #{qt(fts_table_name(model))};")
+        connection.execute("DROP TABLE IF EXISTS #{qt(trigram_table_name(model))};")
       end
 
       def fts_table_name(model)
@@ -71,10 +117,21 @@ module FullSearch
         "#{fts_table_name(model)}_trigram"
       end
 
-      def sqlite?
+      def sqlite?(model = nil)
+        if model
+          model.connection.adapter_name.downcase.include?("sqlite")
+        else
+          connection.adapter_name.downcase.include?("sqlite")
+        end
+      rescue
         connection.adapter_name.downcase.include?("sqlite")
       end
 
+      def sqlite!(model)
+        adapter = model ? model.connection.adapter_name : connection.adapter_name
+        raise UnsupportedDatabaseError, "full_search requires SQLite, but #{adapter} is configured" unless sqlite?(model)
+      end
+
       def stored_config_hash(model)
         row = connection.execute(
           "SELECT config_hash FROM full_search_index_versions WHERE table_name=#{q(model.table_name)}"
@@ -92,6 +149,14 @@ module FullSearch
         connection.quote(value)
       end
 
+      def qt(name)
+        connection.quote_table_name(name)
+      end
+
+      def qc(name)
+        connection.quote_column_name(name)
+      end
+
       def model_table_exists?(model)
         connection.execute(
           "SELECT name FROM sqlite_master WHERE type='table' AND name=#{q(model.table_name)} LIMIT 1"
@@ -122,11 +187,11 @@ module FullSearch
 
       def create_virtual_table_sql(model)
         dsl = model.full_search_dsl
-        columns = (dsl.fields + dsl.filters.map { |f| OpenStruct.new(name: f.name, unindexed?: true) })
-        column_list = columns.map { |c| c.respond_to?(:unindexed?) && c.unindexed? ? "#{c.name} UNINDEXED" : c.name }.join(", ")
+        columns = (dsl.fields + dsl.filters.map { |f| FilterColumnPlaceholder.new(name: f.name) })
+        column_list = columns.map { |c| (c.respond_to?(:unindexed?) && c.unindexed?) ? "#{qc(c.name)} UNINDEXED" : qc(c.name) }.join(", ")
 
         <<~SQL
-          CREATE VIRTUAL TABLE #{fts_table_name(model)} USING fts5(
+          CREATE VIRTUAL TABLE #{qt(fts_table_name(model))} USING fts5(
             #{column_list},
             tokenize='#{dsl.tokenize}'
           );
@@ -140,13 +205,13 @@ module FullSearch
           if c.respond_to?(:source) && c.source
             source_value_sql(c.source)
           else
-            "#{model.table_name}.#{c.name}"
+            "#{qt(model.table_name)}.#{qc(c.name)}"
           end
         end.join(", ")
 
         <<~SQL
-          INSERT INTO #{fts_table_name(model)}(rowid, #{cols.map(&:name).join(", ")})
-          SELECT #{model.table_name}.id, #{select} FROM #{model.table_name};
+          INSERT INTO #{qt(fts_table_name(model))}(rowid, #{cols.map { |c| qc(c.name) }.join(", ")})
+          SELECT #{qt(model.table_name)}.id, #{select} FROM #{qt(model.table_name)};
         SQL
       end
 
@@ -159,13 +224,20 @@ module FullSearch
           "SELECT name FROM sqlite_master WHERE type='trigger' AND tbl_name=#{q(model.table_name)}"
         ).map { |r| r["name"] }
 
-        create_triggers!(model) unless (trigger_names(model) - existing).empty?
+        expected = trigger_names(model)
+        expected += trigram_trigger_names(model) if model.full_search_dsl.typo_tolerance?
+        return if (expected - existing).empty? && (existing - expected).empty?
+
+        rebuild!(model)
       end
 
       def create_triggers!(model)
         connection.execute(insert_trigger_sql(model))
         connection.execute(delete_trigger_sql(model))
         connection.execute(update_trigger_sql(model))
+        if model.full_search_dsl.soft_delete_column
+          connection.execute(soft_delete_removal_trigger_sql(model))
+        end
         if model.full_search_dsl.typo_tolerance?
           connection.execute(insert_trigram_trigger_sql(model))
           connection.execute(delete_trigram_trigger_sql(model))
@@ -175,13 +247,15 @@ module FullSearch
 
       def drop_triggers!(model)
         (trigger_names(model) + trigram_trigger_names(model)).each do |name|
-          connection.execute("DROP TRIGGER IF EXISTS #{name};")
+          connection.execute("DROP TRIGGER IF EXISTS #{qt(name)};")
         end
       end
 
       def trigger_names(model)
         base = fts_table_name(model)
-        %W[#{base}_ai #{base}_ad #{base}_au]
+        names = %W[#{base}_ai #{base}_ad #{base}_au]
+        names << "#{base}_au_soft_delete" if model.full_search_dsl.soft_delete_column
+        names
       end
 
       def trigram_trigger_names(model)
@@ -195,8 +269,8 @@ module FullSearch
         values = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
 
         <<~SQL
-          CREATE TRIGGER #{trigger_names(model).first} AFTER INSERT ON #{model.table_name} BEGIN
-            INSERT INTO #{fts_table_name(model)}(rowid, #{col_names(cols)})
+          CREATE TRIGGER #{qt(trigger_names(model).first)} AFTER INSERT ON #{qt(model.table_name)} BEGIN
+            INSERT INTO #{qt(fts_table_name(model))}(rowid, #{col_names(cols)})
             VALUES (new.id, #{values});
           END;
         SQL
@@ -204,8 +278,8 @@ module FullSearch
 
       def delete_trigger_sql(model)
         <<~SQL
-          CREATE TRIGGER #{trigger_names(model)[1]} AFTER DELETE ON #{model.table_name} BEGIN
-            DELETE FROM #{fts_table_name(model)} WHERE rowid = old.id;
+          CREATE TRIGGER #{qt(trigger_names(model)[1])} AFTER DELETE ON #{qt(model.table_name)} BEGIN
+            DELETE FROM #{qt(fts_table_name(model))} WHERE rowid = old.id;
           END;
         SQL
       end
@@ -215,12 +289,12 @@ module FullSearch
         cols = dsl.fields + dsl.filters
         values = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
         cols_str = col_names(cols)
-        fts_table = fts_table_name(model)
+        fts_table = qt(fts_table_name(model))
 
-        when_clause = SoftDelete.delete_transition_sql(model)
+        when_clause = SoftDelete.active_update_clause(model)
 
         <<~SQL
-          CREATE TRIGGER #{trigger_names(model)[2]} AFTER UPDATE ON #{model.table_name} #{when_clause}
+          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})
@@ -229,6 +303,19 @@ module FullSearch
         SQL
       end
 
+      def soft_delete_removal_trigger_sql(model)
+        model.full_search_dsl
+        fts_table = qt(fts_table_name(model))
+        when_clause = SoftDelete.soft_delete_remove_clause(model)
+
+        <<~SQL
+          CREATE TRIGGER #{qt("#{trigger_names(model)[2]}_soft_delete")} AFTER UPDATE ON #{qt(model.table_name)} #{when_clause}
+          BEGIN
+            DELETE FROM #{fts_table} WHERE rowid = old.id;
+          END;
+        SQL
+      end
+
       def trigram_table_exists?(model)
         connection.execute(
           "SELECT name FROM sqlite_master WHERE type='table' AND name=#{q(trigram_table_name(model))} LIMIT 1"
@@ -237,11 +324,11 @@ module FullSearch
 
       def create_trigram_virtual_table_sql(model)
         dsl = model.full_search_dsl
-        columns = (dsl.fields + dsl.filters.map { |f| OpenStruct.new(name: f.name, unindexed?: true) })
-        column_list = columns.map { |c| c.respond_to?(:unindexed?) && c.unindexed? ? "#{c.name} UNINDEXED" : c.name }.join(", ")
+        columns = (dsl.fields + dsl.filters.map { |f| FilterColumnPlaceholder.new(name: f.name) })
+        column_list = columns.map { |c| (c.respond_to?(:unindexed?) && c.unindexed?) ? "#{qc(c.name)} UNINDEXED" : qc(c.name) }.join(", ")
 
         <<~SQL
-          CREATE VIRTUAL TABLE #{trigram_table_name(model)} USING fts5(
+          CREATE VIRTUAL TABLE #{qt(trigram_table_name(model))} USING fts5(
             #{column_list},
             tokenize='trigram'
           );
@@ -255,13 +342,13 @@ module FullSearch
           if c.respond_to?(:source) && c.source
             source_value_sql(c.source)
           else
-            "#{model.table_name}.#{c.name}"
+            "#{qt(model.table_name)}.#{qc(c.name)}"
           end
         end.join(", ")
 
         <<~SQL
-          INSERT INTO #{trigram_table_name(model)}(rowid, #{cols.map(&:name).join(", ")})
-          SELECT #{model.table_name}.id, #{select} FROM #{model.table_name};
+          INSERT INTO #{qt(trigram_table_name(model))}(rowid, #{cols.map { |c| qc(c.name) }.join(", ")})
+          SELECT #{qt(model.table_name)}.id, #{select} FROM #{qt(model.table_name)};
         SQL
       end
 
@@ -271,8 +358,8 @@ module FullSearch
         values = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
 
         <<~SQL
-          CREATE TRIGGER #{trigram_trigger_names(model).first} AFTER INSERT ON #{model.table_name} BEGIN
-            INSERT INTO #{trigram_table_name(model)}(rowid, #{col_names(cols)})
+          CREATE TRIGGER #{qt(trigram_trigger_names(model).first)} AFTER INSERT ON #{qt(model.table_name)} BEGIN
+            INSERT INTO #{qt(trigram_table_name(model))}(rowid, #{col_names(cols)})
             VALUES (new.id, #{values});
           END;
         SQL
@@ -280,8 +367,8 @@ module FullSearch
 
       def delete_trigram_trigger_sql(model)
         <<~SQL
-          CREATE TRIGGER #{trigram_trigger_names(model)[1]} AFTER DELETE ON #{model.table_name} BEGIN
-            DELETE FROM #{trigram_table_name(model)} WHERE rowid = old.id;
+          CREATE TRIGGER #{qt(trigram_trigger_names(model)[1])} AFTER DELETE ON #{qt(model.table_name)} BEGIN
+            DELETE FROM #{qt(trigram_table_name(model))} WHERE rowid = old.id;
           END;
         SQL
       end
@@ -291,12 +378,12 @@ module FullSearch
         cols = dsl.fields + dsl.filters
         values = cols.map { |c| column_ref(c, prefix: "new") }.join(", ")
         cols_str = col_names(cols)
-        trigram_table = trigram_table_name(model)
+        trigram_table = qt(trigram_table_name(model))
 
-        when_clause = SoftDelete.delete_transition_sql(model)
+        when_clause = SoftDelete.active_update_clause(model)
 
         <<~SQL
-          CREATE TRIGGER #{trigram_trigger_names(model)[2]} AFTER UPDATE ON #{model.table_name} #{when_clause}
+          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})
@@ -306,22 +393,25 @@ module FullSearch
       end
 
       def col_names(cols)
-        cols.map(&:name).join(", ")
+        cols.map { |c| qc(c.name) }.join(", ")
       end
 
       def column_ref(col, prefix:)
         if col.respond_to?(:source) && col.source
           "''"
         else
-          "#{prefix}.#{col.name}"
+          "#{prefix}.#{qc(col.name)}"
         end
       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.
       def with_rebuild_lock(model)
         if FullSearch.config.lock_rebuilds
           connection.transaction do
             connection.execute(
-              "INSERT INTO full_search_index_versions (table_name, config_hash, rebuilt_at) VALUES (#{q(model.table_name)}, #{q("")}, datetime('now'))
+              "INSERT INTO full_search_index_versions (table_name, config_hash, rebuilt_at) VALUES (#{q(model.table_name)}, #{q("__rebuilding__")}, datetime('now'))
                ON CONFLICT(table_name) DO UPDATE SET config_hash=excluded.config_hash;"
             )
             yield