make_taggable 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d3a7c89a48d79f6d985b8290d88007368ecdf983789a7e4881662724a1060a9
-  data.tar.gz: dda60e219b50e10b8948b6b9b260e703d8815f43bd200b1c434875144ae68071
+  metadata.gz: 7988c41c462a75321cf31cb13888a01d87a4dec964b13d2bb8c94876d7291d2a
+  data.tar.gz: 76c39347c15e44dd9bad00317aa4e27f4ef58aadd638507340a74fe6bd5bbbd3
 SHA512:
-  metadata.gz: 7aa7e8b6c7190cbc8fbdcaf54fd5f49bf8f877c3161c7466e7df98eefd8f14eaa208391b47fa5a328db563d489d5e9a6f82b3bfd4b0ce770cdedbf3423f958bc
-  data.tar.gz: 0e868727368e57e72fe627cbbc4b7a4dc2077e459d6ac9131732788fec26a88037bd7ed12cb86a35f3b8308b3df7fa238319c24628f39e698c073e7d0dd8fa68
+  metadata.gz: 89496e3b067d1c4707580b30b4ad1a1be0701e8aa03f1e7de30d2c229b4eec96afd82eec4675e89c32cf5e8f0b3ccf28d7afb0ffcf4a7ada5b9ef2169232dcc2
+  data.tar.gz: bbeef557e819249bc1d13668ec6437401dfcfbe3d995874535c86d5b86747ff46d5e0bb3383905343057c2f773c0658766eed9580f6173789e288571a516f0bb

data/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to this project are documented here.
 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).
 
+## [1.2.0] - 2026-08-23
+
+### Fixed
+
+- `Tag.find_or_create_all_with_like_by_name` recovered from a lost race for a tag name by issuing a
+  raw `ROLLBACK`. That statement is not scoped to the failed insert -- it discarded whatever
+  transaction was open on the connection, which is nearly always one the caller opened, and on a
+  multi-database application it targeted whichever connection `ActiveRecord::Base` held rather than
+  the one the tags are on. Each insert now takes a savepoint of its own.
+
+- `remove_unused_tags` did nothing at all when `tags_counter` was off, because the check read the
+  counter cache. With the counter off it now asks the tag's taggings directly, at the cost of one
+  indexed lookup per destroyed tagging. The documentation said the setting required `tags_counter`;
+  it no longer does.
+
+- `Utils.using_postgresql?` matched only the adapter named `PostgreSQL`, so a PostGIS application
+  took the MySQL path -- `LIKE` in place of `ILIKE`, which quietly made tag matching
+  case-sensitive, and the wrong grouping strategy in `all_tags_on` and `find_related_*`.
+
+### Changed
+
+- A migration dropping five indexes from `taggings` that no query planner can reach: `tag_id`,
+  `taggable_id`, `taggable_type` and `tagger_id` on their own, each a leading column of an index
+  that remains, plus a second copy of the tagger pair in the opposite column order. Twelve indexes
+  become seven, and every one of them is maintained on insert.
+
+  Install it with `rails make_taggable_engine:install:migrations`. It is reversible -- see
+  [docs/database.md](docs/database.md).
+
 ## [1.1.1] - 2026-08-22
 
 ### Fixed

data/db/migrate/7_remove_redundant_tagging_indexes.rb

@@ -0,0 +1,38 @@
+class RemoveRedundantTaggingIndexes < ActiveRecord::Migration[7.2]
+  # Migrations 2 and 5 between them put twelve indexes on the taggings table.
+  # Five of them earn nothing: a B-tree index already answers any query that
+  # filters on a leading subset of its columns, so an index on a single column
+  # is dead weight whenever another index starts with that same column.
+  #
+  #   tag_id        -> covered by taggings_idx and taggings_unowned_idx
+  #   taggable_id   -> covered by taggings_taggable_context_idx and taggings_idy
+  #   taggable_type -> covered by index_taggings_on_taggable_type_and_taggable_id
+  #   tagger_id     -> covered by index_taggings_on_tagger_id_and_tagger_type
+  #
+  # The fifth is the tagger pair, which migration 2 and migration 5 each added
+  # in opposite column orders. One of the two is enough; the order kept is the
+  # one the library's own queries filter in, tagger_id first.
+  #
+  # Every index is maintained on insert, so this is a write-cost and a
+  # disk-footprint change, not a query-plan one. Nothing here is load-bearing:
+  # each dropped index is a prefix of one that remains.
+  REDUNDANT_COLUMNS = [
+    [:tag_id],
+    [:taggable_id],
+    [:taggable_type],
+    [:tagger_id],
+    [:tagger_type, :tagger_id]
+  ].freeze
+
+  def up
+    REDUNDANT_COLUMNS.each do |columns|
+      remove_index MakeTaggable.taggings_table, column: columns if index_exists?(MakeTaggable.taggings_table, columns)
+    end
+  end
+
+  def down
+    REDUNDANT_COLUMNS.each do |columns|
+      add_index MakeTaggable.taggings_table, columns unless index_exists?(MakeTaggable.taggings_table, columns)
+    end
+  end
+end

data/docs/configuration.md

@@ -51,14 +51,18 @@ The library avoids creating both, but data loaded another way can still contain
 
 ### `remove_unused_tags`
 
-When the last tagging referencing a tag is destroyed, the tag row is destroyed too. Requires
-`tags_counter`, since it reads the counter cache to decide.
+When the last tagging referencing a tag is destroyed, the tag row is destroyed too.
+
+This works whether or not `tags_counter` is on. With the counter cache the tag row already carries
+the count and is only re-read; without it the tag's remaining taggings are queried directly, which
+costs one extra query per destroyed tagging.
 
 ### `tags_counter`
 
 Keeps `tags.taggings_count` up to date. Turning it off avoids a write to the tags row on every
-tagging, at the cost of `Tag.most_used`, `Tag.least_used` and `remove_unused_tags`, all of which
-read that counter.
+tagging, at the cost of `Tag.most_used` and `Tag.least_used`, both of which read that counter.
+
+`remove_unused_tags` is unaffected -- it falls back to querying the tag's taggings.
 
 Changing this on an existing application leaves the existing counts frozen at their current values
 rather than resetting them.

data/docs/database.md

@@ -26,13 +26,48 @@ Both table names are configurable — see [configuration.md](configuration.md).
 
 ## Indexes
 
-The shipped migrations index `taggings` heavily: the polymorphic references index themselves, and
-migration 5 adds standalone indexes on `taggable_id`, `tagger_id`, `taggable_type` and `context`,
-plus four composites.
+Migrations 2 and 5 between them put twelve indexes on `taggings`. Migration 7 drops five of them,
+leaving seven:
 
-That suits read-heavy tagging. If your application writes taggings in bulk, the write cost is worth
-looking at — every index is maintained on insert, and several of the standalone ones are prefixes of
-composites that already exist. Drop what your queries do not use.
+| Index | Columns | Why it is there |
+|---|---|---|
+| `taggings_idx` | `tag_id, taggable_id, taggable_type, context, tagger_id, tagger_type` | Unique. Stops a tag being applied twice in the same context by the same tagger |
+| `taggings_unowned_idx` | `tag_id, taggable_id, taggable_type, context` where `tagger_id IS NULL` | Unique, partial. See below. Not created on MySQL |
+| `taggings_taggable_context_idx` | `taggable_id, taggable_type, context` | Reading one record's tags in one context |
+| `taggings_idy` | `taggable_id, taggable_type, tagger_id, context` | Reading one record's owned tags |
+| — | `taggable_type, taggable_id` | The polymorphic association lookup |
+| — | `tagger_id, tagger_type` | `Tagging.owned_by`, and `tagged_with(owned_by:)` |
+| — | `context` | Filtering taggings by context alone |
+
+The five migration 7 removes were `tag_id`, `taggable_id`, `taggable_type` and `tagger_id` on their
+own, plus a second copy of the tagger pair in the opposite column order. A B-tree index already
+answers any query filtering on a leading subset of its columns, so a single-column index earns
+nothing when another index starts with that same column — and every index is maintained on insert.
+
+If you installed the migrations before version 1.2.0, running
+`rails make_taggable_engine:install:migrations` again copies migration 7 across. It is reversible,
+and nothing it drops is load-bearing: each one is a prefix of an index that remains.
+
+### Concurrent tag creation
+
+`tags.name` carries a unique index, so two requests creating the same tag at the same moment leave
+one of them holding an `ActiveRecord::RecordNotUnique`.
+
+`Tag.find_or_create_all_with_like_by_name` -- which every tag list goes through -- absorbs that. It
+re-reads the tags and retries, up to three times, and raises
+{MakeTaggable::DuplicateTagError} if the name is still taken after that.
+
+Each insert takes a savepoint of its own, so the failed insert is the only thing rolled back. If you
+call this inside a transaction of your own, that transaction and everything written into it survive
+the retry:
+
+```ruby
+Order.transaction do
+  order.update!(state: "placed")
+  order.tag_list = "priority"   # a race here rolls back nothing but the tag insert
+  order.save!
+end
+```
 
 ### Duplicate unowned taggings
 

data/lib/make_taggable/tag.rb

@@ -139,6 +139,9 @@ module MakeTaggable
     # Finds every tag in a list by name, creating those that do not exist yet.
     #
     # A competing write that takes a name first is retried up to three times before giving up.
+    # Each insert runs in a savepoint of its own, so a name lost to a race unwinds that insert
+    # alone -- an enclosing transaction the caller opened is left untouched, along with everything
+    # written into it.
     #
     # @param list [Array<String>] the tag names
     # @return [Array<MakeTaggable::Tag>] in the order the names were given
@@ -162,10 +165,13 @@ module MakeTaggable
         # Tags created earlier in this call have to stay visible to the names
         # that follow, or a list holding both "Ruby" and "ruby" resolves to two
         # rows even though the two names compare equal.
-        create(name: tag_name).tap { |tag| existing_tags << tag }
+        #
+        # The insert gets a savepoint of its own so that a RecordNotUnique
+        # unwinds only the failed insert. Without one the caller's transaction
+        # is left in an aborted state and everything it had done is lost.
+        transaction(requires_new: true) { create(name: tag_name) }.tap { |tag| existing_tags << tag }
       rescue ActiveRecord::RecordNotUnique
         if (tries -= 1).positive?
-          ActiveRecord::Base.connection.execute "ROLLBACK"
           existing_tags = named_any(list).to_a
           retry
         end

data/lib/make_taggable/tagging.rb

@@ -50,8 +50,21 @@ module MakeTaggable
 
     private
 
+    # Destroys the tag this tagging pointed at, if nothing else references it and the library is
+    # configured to clean up after itself. Runs after destroy.
+    #
+    # How "nothing else references it" is established depends on the counter cache. With
+    # `tags_counter` on, the count is already on the row and only needs re-reading. With it off
+    # there is no count to read, so the taggings are asked directly -- `none?` stops at the first
+    # row rather than counting them all.
+    #
+    # @return [void]
     def remove_unused_tags
-      if MakeTaggable.remove_unused_tags && MakeTaggable.tags_counter && tag.reload.taggings_count.zero?
+      return unless MakeTaggable.remove_unused_tags
+
+      if MakeTaggable.tags_counter
+        tag.destroy if tag.reload.taggings_count.zero?
+      elsif tag.taggings.reload.none?
         tag.destroy
       end
     end

data/lib/make_taggable/utils.rb

@@ -5,6 +5,17 @@ module MakeTaggable
   # Database differences the rest of the library needs to work around.
   #
   module Utils
+    ##
+    # Adapter names that are PostgreSQL as far as SQL generation is concerned.
+    #
+    # PostGIS is the PostgreSQL adapter with spatial types layered on top. It reports its own
+    # adapter name, so it has to be named here or the library treats a PostGIS application as
+    # though it were on MySQL -- `LIKE` in place of `ILIKE`, and the wrong grouping strategy.
+    #
+    # @return [Array<String>] frozen
+    #
+    POSTGRESQL_ADAPTER_NAMES = %w[PostgreSQL PostGIS].freeze
+
     class << self
       ##
       # The connection tags are read and written through.
@@ -18,10 +29,12 @@ module MakeTaggable
       ##
       # Whether tags are stored in PostgreSQL.
       #
+      # True for PostGIS as well, which is PostgreSQL underneath.
+      #
       # @return [TrueClass, FalseClass]
       #
       def using_postgresql?
-        connection && connection.adapter_name == "PostgreSQL"
+        !!connection && POSTGRESQL_ADAPTER_NAMES.include?(connection.adapter_name)
       end
 
       ##
@@ -47,7 +60,7 @@ module MakeTaggable
       ##
       # The case-insensitive pattern operator for the current adapter.
       #
-      # @return [String] `"ILIKE"` on PostgreSQL, otherwise `"LIKE"`
+      # @return [String] `"ILIKE"` on PostgreSQL and PostGIS, otherwise `"LIKE"`
       #
       def like_operator
         using_postgresql? ? "ILIKE" : "LIKE"

data/lib/make_taggable/version.rb

@@ -6,5 +6,5 @@ module MakeTaggable
   #
   # @return [String]
   #
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/make_taggable.rb

@@ -141,7 +141,8 @@ module MakeTaggable
   #   Whether tag names are parameterized before they are saved.
   #   @return [TrueClass, FalseClass] defaults to `false`
   # @!attribute [rw] remove_unused_tags
-  #   Whether a tag row is destroyed once its last tagging goes away. Requires `tags_counter`.
+  #   Whether a tag row is destroyed once its last tagging goes away. Works with or without
+  #   `tags_counter`; without it the check costs one extra query per destroyed tagging.
   #   @return [TrueClass, FalseClass] defaults to `false`
   # @!attribute [rw] default_parser
   #   The class used to turn tag input into a {MakeTaggable::TagList}.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: make_taggable
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Matthew Kennedy
@@ -47,6 +47,7 @@ files:
 - db/migrate/4_add_index_to_tags.rb
 - db/migrate/5_add_index_to_taggings.rb
 - db/migrate/6_add_unowned_taggings_unique_index.rb
+- db/migrate/7_remove_redundant_tagging_indexes.rb
 - docs/caching.md
 - docs/configuration.md
 - docs/contexts.md