metka 2.3.4 → 3.0.0

data/docs/superpowers/specs/2026-08-18-cloud-table-naming-design.md

@@ -0,0 +1,105 @@
+# Table-Strategy Summary Table Naming: `<source_table>_<columns>_cloud`
+
+**Date:** 2026-08-18
+**Status:** Approved by user
+**Target:** 3.0 release
+
+## Problem
+
+The table strategy generator derives its summary table name as
+`tagged_<source_table>` (e.g. `tagged_songs`), or
+`tagged_with_<columns>_<source_table>` when non-default source columns are
+given (e.g. `tagged_with_tags_and_genres_posts`). The prefix style reads
+poorly, sorts the table away from its source table in the schema, and is
+inconsistent with the index strategy, which names its tables
+`<source_table>_<column>_index` (e.g. `posts_tags_index`).
+
+The summary table is not a taggings join table: it holds one row per tag
+(`tag_name varchar PRIMARY KEY, taggings_count bigint`) — a tag-cloud
+aggregate maintained by triggers. The name should describe that.
+
+## Decision
+
+Rename the derived default to `<source_table>_<columns>_cloud`, with columns
+joined by `_and_`, uniformly — no special case for the default `tags` column:
+
+| Input | Old derived name | New derived name |
+|---|---|---|
+| `--source-table-name=songs` | `tagged_songs` | `songs_tags_cloud` |
+| `--source-table-name=posts --source-columns=tags genres` | `tagged_with_tags_and_genres_posts` | `posts_tags_and_genres_cloud` |
+
+This mirrors the index strategy's `<source_table>_<column>_index` pattern, so
+the two strategies' tables read as siblings in the schema
+(`songs_tags_cloud`, `songs_tags_index`), and matches the feature's name
+throughout the README and API (`tag_cloud`).
+
+Alternatives considered and rejected:
+
+- `song_taggings` (`<singular>_taggings`): Rails-idiomatic, but in the Rails
+  ecosystem "taggings" implies a join table with one row per tagging;
+  this table holds per-tag counts, so the name misleads schema readers.
+- `song_tag_counts`: semantically precise but breaks symmetry with the index
+  strategy and derives awkwardly for non-default columns.
+
+## Changes
+
+### Generator (the only code change)
+
+`lib/generators/metka/strategies/table/table_generator.rb` — `table_name`
+becomes:
+
+```ruby
+def table_name
+  return options[:table_name] if options[:table_name]
+
+  "#{source_table_name}_#{source_columns_names}_cloud"
+end
+```
+
+- The migration name keeps its existing `create_#{table_name}_table`
+  derivation (→ `create_songs_tags_cloud_table`).
+- The `--table-name` option remains as the override, unchanged.
+
+### Templates: no changes
+
+Both `migration.rb.erb` (PostgreSQL) and `migration.sqlite.rb.erb` (SQLite)
+interpolate `<%= table_name %>` throughout — trigger function names become
+`metka_ins_songs_tags_cloud()` etc. automatically. Trigger names derive from
+the source table and columns, not the summary table, so they are untouched.
+
+### Docs and fixtures (model the new convention)
+
+- `test/generators/strategies/table_generator_test.rb`: expected table and
+  migration names, including the trigger-function name assertions
+  (`metka_ins_tagged_notes` → `metka_ins_notes_tags_cloud`); trigger-name
+  assertions (`metka_ins_on_notes_...`) stay as they are.
+- `README.md` table-strategy section: `tagged_notes` → `notes_tags_cloud`,
+  `TaggedNote` → `NotesTagsCloud`, and the derived-name explanation.
+- Dummy app: `test/dummy/db/migrate/11_create_tagged_table_posts_table.rb`
+  and the `TaggedTablePost` model/test rename to the new convention
+  (summary table `table_posts_tags_cloud`).
+- `benchmark/benchmark.rb`: table strategy table (`tagged_metka_table_posts`)
+  renamed to match. `benchmark/README.md` never names the table literally, so
+  it needs no change.
+
+Pluralization note: Rails infers `notes_tags_clouds` (plural) from a model
+named `NotesTagsCloud`, so the renamed dummy model and the README example
+model must set `self.table_name = "notes_tags_cloud"` explicitly — the old
+`TaggedNote` → `tagged_notes` inference worked by accident of the naming.
+
+## Compatibility
+
+Generation-time only. The table name is baked into a migration when the user
+runs the generator; no runtime code derives or reads the `tagged_` prefix.
+Existing installs keep their `tagged_*` tables and working triggers untouched;
+only newly generated migrations change. No deprecation shim is needed. The
+README is the only doc surface (no CHANGELOG file in the repo).
+
+## Testing
+
+- Updated generator tests assert the new derived names for the default and
+  multi-column cases, and that `--table-name` still overrides.
+- Existing dummy-app trigger tests run against the renamed summary table,
+  proving the templates work unchanged with the new name.
+
+No new test types are needed.

data/forspell.dict

@@ -4,4 +4,6 @@
 # Example: deduplicate: duplicate
 Metka
 taggings
-benchmarked
+benchmarked
+gutentag
+backfill: fill

data/gemfiles/rails71.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 7.1.0'
+gem 'activerecord', '~> 7.1.0'
+
+gemspec path: '..'

data/gemfiles/rails72.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 7.2.0'
+gem 'activerecord', '~> 7.2.0'
+
+gemspec path: '..'

data/gemfiles/rails80.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 8.0.0'
+gem 'activerecord', '~> 8.0.0'
+
+gemspec path: '..'

data/gemfiles/rails81.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 8.1.0'
+gem 'activerecord', '~> 8.1.0'
+
+gemspec path: '..'

data/gemfiles/rubocop.gemfile

@@ -1,4 +1,4 @@
 source "https://rubygems.org" do
   gem "rubocop-md", "~> 1.0"
-  gem "jetrockets-standard"
-end
+  gem "rubocop-rails-omakase", "~> 1.1"
+end

data/lib/generators/metka/strategies/index/index_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Metka
+  module Generators
+    module Strategies
+      class IndexGenerator < ::Rails::Generators::Base # :nodoc:
+        include Rails::Generators::Migration
+
+        DEFAULT_SOURCE_COLUMNS = [ "tags" ].freeze
+
+        desc <<~LONGDESC
+          Generates a migration implementing the SQLite index strategy for
+          Metka: one (tag_name, record_id) side table per tagged column,
+          maintained by triggers, so tag queries become index seeks instead
+          of json_each table scans. Declare the tables on the model with the
+          index_tables option to route queries through them.
+
+          PostgreSQL needs no index strategy — GIN indexes on the array
+          columns already serve tag queries — so the generator produces
+          nothing there.
+
+          > $ rails g metka:strategies:index \
+          --source-table-name=NAME_OF_TABLE_WITH_TAGS \
+          --source-columns=NAME_OF_TAGGED_COLUMN_1 NAME_OF_TAGGED_COLUMN_2
+        LONGDESC
+
+        source_root File.expand_path("templates", __dir__)
+
+        class_option :source_table_name, type: :string, required: true,
+          desc: "Name of the table that has a column with tags"
+
+        class_option :source_columns, type: :array, default: DEFAULT_SOURCE_COLUMNS,
+          desc: "List of the tagged columns names"
+
+        def generate_migration
+          unless sqlite?
+            say_status :skipped,
+              "the index strategy targets SQLite; PostgreSQL GIN indexes already serve tag queries",
+              :yellow
+            return
+          end
+
+          migration_template "migration.rb.erb", "db/migrate/#{migration_name}.rb"
+        end
+
+        no_tasks do
+          def sqlite?
+            ::ActiveRecord::Base.connection.adapter_name.match?(/sqlite/i)
+          end
+
+          def source_table_name
+            options[:source_table_name]
+          end
+
+          def source_columns
+            options[:source_columns]
+          end
+
+          def index_table_for(column)
+            "#{source_table_name}_#{column}_index"
+          end
+
+          def migration_name
+            "create_#{source_table_name}_#{source_columns.join('_and_')}_index_tables"
+          end
+        end
+
+        def self.next_migration_number(dir)
+          ::ActiveRecord::Generators::Base.next_migration_number(dir)
+        end
+      end
+    end
+  end
+end

data/lib/generators/metka/strategies/index/templates/migration.rb.erb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
+  # One (tag_name, record_id) side table per tagged column, so SQLite tag
+  # queries become index seeks instead of json_each table scans. The WITHOUT
+  # ROWID primary key (tag_name, record_id) is itself the covering index —
+  # no separate index needed — and doubles as the dedup guard: a tag
+  # duplicated inside one row's array stores a single pair, which is all
+  # membership queries need.
+  #
+  # Per-row triggers keep the pairs in step with every INSERT, UPDATE and
+  # DELETE, multi-row statements included. Deletes seek through the primary
+  # key (tag_name from OLD's array, then record_id), so no extra index on
+  # record_id is required. Writes that bypass the triggers (restoring from a
+  # dump) require reseeding the table by hand.
+  #
+  # Declare the tables on the model to route queries through them:
+  #
+  #   include Metka::Model(
+  #     columns: %w[<%= source_columns.join(' ') %>],
+  #     index_tables: {
+<% source_columns.each do |column| -%>
+  #       "<%= column %>" => "<%= index_table_for(column) %>",
+<% end -%>
+  #     }
+  #   )
+  def up
+<% source_columns.each do |column| -%>
+    execute <<-SQL
+    CREATE TABLE <%= index_table_for(column) %> (
+      tag_name varchar NOT NULL,
+      record_id bigint NOT NULL,
+      PRIMARY KEY (tag_name, record_id)
+    ) WITHOUT ROWID;
+    SQL
+
+    execute <<-SQL
+    INSERT OR IGNORE INTO <%= index_table_for(column) %> (tag_name, record_id)
+      SELECT value, <%= source_table_name %>.id
+      FROM <%= source_table_name %>, json_each(<%= source_table_name %>.<%= column %>);
+    SQL
+
+    execute <<-SQL
+    CREATE TRIGGER metka_idx_ins_on_<%= source_table_name %>_<%= column %>
+    AFTER INSERT ON <%= source_table_name %>
+    FOR EACH ROW
+    BEGIN
+      INSERT OR IGNORE INTO <%= index_table_for(column) %> (tag_name, record_id)
+      SELECT value, NEW.id FROM json_each(NEW.<%= column %>);
+    END;
+    SQL
+
+    execute <<-SQL
+    CREATE TRIGGER metka_idx_upd_on_<%= source_table_name %>_<%= column %>
+    AFTER UPDATE OF <%= column %> ON <%= source_table_name %>
+    FOR EACH ROW
+    BEGIN
+      DELETE FROM <%= index_table_for(column) %>
+      WHERE tag_name IN (SELECT value FROM json_each(OLD.<%= column %>))
+        AND record_id = OLD.id;
+
+      INSERT OR IGNORE INTO <%= index_table_for(column) %> (tag_name, record_id)
+      SELECT value, NEW.id FROM json_each(NEW.<%= column %>);
+    END;
+    SQL
+
+    execute <<-SQL
+    CREATE TRIGGER metka_idx_del_on_<%= source_table_name %>_<%= column %>
+    AFTER DELETE ON <%= source_table_name %>
+    FOR EACH ROW
+    BEGIN
+      DELETE FROM <%= index_table_for(column) %>
+      WHERE tag_name IN (SELECT value FROM json_each(OLD.<%= column %>))
+        AND record_id = OLD.id;
+    END;
+    SQL
+
+<% end -%>
+  end
+
+  def down
+<% source_columns.each do |column| -%>
+    execute "DROP TRIGGER IF EXISTS metka_idx_ins_on_<%= source_table_name %>_<%= column %>;"
+    execute "DROP TRIGGER IF EXISTS metka_idx_upd_on_<%= source_table_name %>_<%= column %>;"
+    execute "DROP TRIGGER IF EXISTS metka_idx_del_on_<%= source_table_name %>_<%= column %>;"
+    execute "DROP TABLE IF EXISTS <%= index_table_for(column) %>;"
+<% end -%>
+  end
+end

data/lib/generators/metka/strategies/table/table_generator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Metka
+  module Generators
+    module Strategies
+      class TableGenerator < ::Rails::Generators::Base # :nodoc:
+        include Rails::Generators::Migration
+
+        DEFAULT_SOURCE_COLUMNS = [ "tags" ].freeze
+
+        desc <<~LONGDESC
+          Generates migration to implement table strategy for Metka
+
+          > $ rails g metka:strategies:table \
+          --source-table-name=NAME_OF_TABLE_WITH_TAGS \
+          --source-columns=NAME_OF_TAGGED_COLUMN_1 NAME_OF_TAGGED_COLUMN_2 \
+          --table-name=NAME_OF_TABLE
+        LONGDESC
+
+        source_root File.expand_path("templates", __dir__)
+
+        class_option :source_table_name, type: :string, required: true,
+          desc: "Name of the table that has a column with tags"
+
+        class_option :source_columns, type: :array, default: DEFAULT_SOURCE_COLUMNS,
+          desc: "List of the tagged columns names"
+
+        class_option :table_name, type: :string,
+          desc: "Custom name for the resulting table"
+
+        def generate_migration
+          migration_template migration_template_file, "db/migrate/#{migration_name}.rb"
+        end
+
+        no_tasks do
+          # The migration is written for the database the app is connected to
+          # at generation time: transition-table triggers for PostgreSQL,
+          # per-row json_each triggers for SQLite.
+          def migration_template_file
+            if ::ActiveRecord::Base.connection.adapter_name.match?(/sqlite/i)
+              "migration.sqlite.rb.erb"
+            else
+              "migration.rb.erb"
+            end
+          end
+
+          def source_table_name
+            options[:source_table_name]
+          end
+
+          def source_columns
+            options[:source_columns]
+          end
+
+          def source_columns_names
+            source_columns.join("_and_")
+          end
+
+          def table_name
+            return options[:table_name] if options[:table_name]
+
+            "#{source_table_name}_#{source_columns_names}_cloud"
+          end
+
+          def migration_name
+            "create_#{table_name}_table"
+          end
+
+          def migration_class_name
+            migration_name.classify
+          end
+        end
+
+        def self.next_migration_number(dir)
+          ::ActiveRecord::Generators::Base.next_migration_number(dir)
+        end
+      end
+    end
+  end
+end

data/lib/generators/metka/strategies/table/templates/migration.rb.erb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
+  def up
+    execute <<-SQL
+    -- A real table maintained by per-tag deltas: statement-level triggers read
+    -- the transition tables and upsert only the tags the statement touched, so
+    -- maintenance cost is O(tags touched) instead of a full recompute. Writes
+    -- that bypass these triggers (TRUNCATE, restoring from a dump) require
+    -- reseeding the table by hand.
+
+    -- Block writes (reads stay unblocked) until the triggers exist: a write
+    -- committing between the seed's snapshot and CREATE TRIGGER would be seen
+    -- by neither and drift the counts. CREATE TRIGGER takes this same lock
+    -- level anyway; this only takes it before the seed instead of after.
+    LOCK TABLE <%= source_table_name %> IN SHARE ROW EXCLUSIVE MODE;
+
+    CREATE TABLE <%= table_name %> (
+      tag_name varchar PRIMARY KEY,
+      taggings_count bigint NOT NULL
+    );
+
+    INSERT INTO <%= table_name %> (tag_name, taggings_count)
+      SELECT
+        tag_name,
+        COUNT(*) AS taggings_count
+      FROM (
+        SELECT UNNEST
+          (<%= source_columns.join(' || ') %>) AS tag_name
+        FROM
+          <%= source_table_name %>
+      ) subquery
+      GROUP BY
+        tag_name;
+
+    -- UNNEST of a NULL array yields no rows and array concatenation treats a
+    -- NULL operand as empty, so NULL tagged columns need no explicit guards.
+    -- One function per operation: a transition table is only registered for
+    -- its own trigger, so the other operations' functions would fail to parse.
+    CREATE OR REPLACE FUNCTION metka_ins_<%= table_name %>() RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        INSERT INTO <%= table_name %> (tag_name, taggings_count)
+        SELECT tag_name, COUNT(*)
+        FROM (
+          SELECT UNNEST (<%= source_columns.join(' || ') %>) AS tag_name
+          FROM new_rows
+        ) subquery
+        GROUP BY tag_name
+        ON CONFLICT (tag_name)
+        DO UPDATE SET taggings_count = <%= table_name %>.taggings_count + EXCLUDED.taggings_count;
+        RETURN NULL;
+      END $$;
+
+    CREATE OR REPLACE FUNCTION metka_upd_<%= table_name %>() RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        WITH deltas AS (
+          SELECT tag_name, SUM(d) AS delta
+          FROM (
+            SELECT UNNEST (<%= source_columns.join(' || ') %>) AS tag_name, 1 AS d FROM new_rows
+            UNION ALL
+            SELECT UNNEST (<%= source_columns.join(' || ') %>) AS tag_name, -1 AS d FROM old_rows
+          ) changes
+          GROUP BY tag_name
+          HAVING SUM(d) <> 0
+        )
+        INSERT INTO <%= table_name %> (tag_name, taggings_count)
+        SELECT tag_name, delta FROM deltas
+        ON CONFLICT (tag_name)
+        DO UPDATE SET taggings_count = <%= table_name %>.taggings_count + EXCLUDED.taggings_count;
+
+        DELETE FROM <%= table_name %> WHERE taggings_count <= 0;
+        RETURN NULL;
+      END $$;
+
+    CREATE OR REPLACE FUNCTION metka_del_<%= table_name %>() RETURNS trigger LANGUAGE plpgsql AS $$
+      BEGIN
+        UPDATE <%= table_name %>
+        SET taggings_count = <%= table_name %>.taggings_count - removed.taggings_count
+        FROM (
+          SELECT tag_name, COUNT(*) AS taggings_count
+          FROM (
+            SELECT UNNEST (<%= source_columns.join(' || ') %>) AS tag_name
+            FROM old_rows
+          ) subquery
+          GROUP BY tag_name
+        ) removed
+        WHERE <%= table_name %>.tag_name = removed.tag_name;
+
+        DELETE FROM <%= table_name %> WHERE taggings_count <= 0;
+        RETURN NULL;
+      END $$;
+
+    -- The ins/upd/del discriminator sits at the front of the trigger names so
+    -- they stay distinct even when PostgreSQL truncates identifiers to 63
+    -- characters. One trigger per operation: a trigger with transition tables
+    -- must be declared for exactly one event.
+    CREATE TRIGGER metka_ins_on_<%= source_table_name %>_<%= source_columns_names %>
+    AFTER INSERT ON <%= source_table_name %>
+    REFERENCING NEW TABLE AS new_rows
+    FOR EACH STATEMENT
+    EXECUTE PROCEDURE metka_ins_<%= table_name %>();
+
+    CREATE TRIGGER metka_upd_on_<%= source_table_name %>_<%= source_columns_names %>
+    AFTER UPDATE ON <%= source_table_name %>
+    REFERENCING OLD TABLE AS old_rows NEW TABLE AS new_rows
+    FOR EACH STATEMENT
+    EXECUTE PROCEDURE metka_upd_<%= table_name %>();
+
+    CREATE TRIGGER metka_del_on_<%= source_table_name %>_<%= source_columns_names %>
+    AFTER DELETE ON <%= source_table_name %>
+    REFERENCING OLD TABLE AS old_rows
+    FOR EACH STATEMENT
+    EXECUTE PROCEDURE metka_del_<%= table_name %>();
+    SQL
+  end
+
+  def down
+    execute <<-SQL
+      DROP TRIGGER IF EXISTS metka_ins_on_<%= source_table_name %>_<%= source_columns_names %> ON <%= source_table_name %>;
+      DROP TRIGGER IF EXISTS metka_upd_on_<%= source_table_name %>_<%= source_columns_names %> ON <%= source_table_name %>;
+      DROP TRIGGER IF EXISTS metka_del_on_<%= source_table_name %>_<%= source_columns_names %> ON <%= source_table_name %>;
+      DROP FUNCTION IF EXISTS metka_ins_<%= table_name %>;
+      DROP FUNCTION IF EXISTS metka_upd_<%= table_name %>;
+      DROP FUNCTION IF EXISTS metka_del_<%= table_name %>;
+      DROP TABLE IF EXISTS <%= table_name %>;
+    SQL
+  end
+end

data/lib/generators/metka/strategies/table/templates/migration.sqlite.rb.erb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
+  # A real table maintained by per-tag deltas. SQLite has no statement-level
+  # triggers or transition tables, so per-row triggers read NEW/OLD
+  # through json_each and apply the deltas one row at a time; multi-row
+  # statements (insert_all, update_all, delete_all) still keep exact counts
+  # because the trigger fires once per affected row. SQLite allows one writer
+  # per database and DDL is transactional, so nothing can write between the
+  # seed and CREATE TRIGGER and no explicit lock is needed. Writes that bypass
+  # the triggers (restoring from a dump) require reseeding the table by hand.
+  #
+  # Requires SQLite >= 3.35 for ON CONFLICT inside a trigger body. The
+  # WHERE true in the upsert disambiguates ON CONFLICT from a join clause in
+  # the INSERT ... SELECT form — a documented SQLite parser requirement.
+  # json_each(NULL) yields no rows, so NULL tagged columns need no guards, and
+  # a tag duplicated inside one row's array upserts once per occurrence —
+  # counted exactly as PostgreSQL's UNNEST-based triggers count it.
+  def up
+    execute <<-SQL
+    CREATE TABLE <%= table_name %> (
+      tag_name varchar PRIMARY KEY,
+      taggings_count bigint NOT NULL
+    );
+    SQL
+
+    execute <<-SQL
+    INSERT INTO <%= table_name %> (tag_name, taggings_count)
+      SELECT tag_name, COUNT(*)
+      FROM (
+        <%= source_columns.map { |column| "SELECT value AS tag_name FROM #{source_table_name}, json_each(#{source_table_name}.#{column})" }.join("\n        UNION ALL\n        ") %>
+      )
+      GROUP BY tag_name;
+    SQL
+
+    execute <<-SQL
+    CREATE TRIGGER metka_ins_on_<%= source_table_name %>_<%= source_columns_names %>
+    AFTER INSERT ON <%= source_table_name %>
+    FOR EACH ROW
+    BEGIN
+<% source_columns.each do |column| -%>
+      INSERT INTO <%= table_name %> (tag_name, taggings_count)
+      SELECT value, 1 FROM json_each(NEW.<%= column %>) WHERE true
+      ON CONFLICT (tag_name)
+      DO UPDATE SET taggings_count = taggings_count + 1;
+<% end -%>
+    END;
+    SQL
+
+    execute <<-SQL
+    CREATE TRIGGER metka_upd_on_<%= source_table_name %>_<%= source_columns_names %>
+    AFTER UPDATE OF <%= source_columns.join(", ") %> ON <%= source_table_name %>
+    FOR EACH ROW
+    BEGIN
+<% source_columns.each do |column| -%>
+      INSERT INTO <%= table_name %> (tag_name, taggings_count)
+      SELECT value, 1 FROM json_each(NEW.<%= column %>) WHERE true
+      ON CONFLICT (tag_name)
+      DO UPDATE SET taggings_count = taggings_count + 1;
+<% end -%>
+<% source_columns.each do |column| -%>
+      UPDATE <%= table_name %>
+      SET taggings_count = taggings_count -
+        (SELECT COUNT(*) FROM json_each(OLD.<%= column %>) WHERE value = tag_name)
+      WHERE tag_name IN (SELECT value FROM json_each(OLD.<%= column %>));
+<% end -%>
+      DELETE FROM <%= table_name %> WHERE taggings_count <= 0;
+    END;
+    SQL
+
+    execute <<-SQL
+    CREATE TRIGGER metka_del_on_<%= source_table_name %>_<%= source_columns_names %>
+    AFTER DELETE ON <%= source_table_name %>
+    FOR EACH ROW
+    BEGIN
+<% source_columns.each do |column| -%>
+      UPDATE <%= table_name %>
+      SET taggings_count = taggings_count -
+        (SELECT COUNT(*) FROM json_each(OLD.<%= column %>) WHERE value = tag_name)
+      WHERE tag_name IN (SELECT value FROM json_each(OLD.<%= column %>));
+<% end -%>
+      DELETE FROM <%= table_name %> WHERE taggings_count <= 0;
+    END;
+    SQL
+  end
+
+  def down
+    execute "DROP TRIGGER IF EXISTS metka_ins_on_<%= source_table_name %>_<%= source_columns_names %>;"
+    execute "DROP TRIGGER IF EXISTS metka_upd_on_<%= source_table_name %>_<%= source_columns_names %>;"
+    execute "DROP TRIGGER IF EXISTS metka_del_on_<%= source_table_name %>_<%= source_columns_names %>;"
+    execute "DROP TABLE IF EXISTS <%= table_name %>;"
+  end
+end