worker_plugins 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13eab7a67becfdbd1809b1930d1314a86c6c0cb217d39ae19181e1dec7453976
-  data.tar.gz: 65b838cc21313b78f92d43b85a95adba991f50360d05be8ec11a2050b4b75133
+  metadata.gz: 46a8d25556ad9d41f62307376bf457a790ab3e67e934678cac0ad9b754112e8e
+  data.tar.gz: 2163df96c0f85a9102f1694fbeda59f06f70c296924e0a9dd9320a0b239e0f15
 SHA512:
-  metadata.gz: 46ebc5d54657090702d0280e72c5f0d863effcbe7ea478892f492b81bfba829a478220fddbde9f2c9df9e7dc7efc07fa3ec5518aa6b455de81be41c7297e72d9
-  data.tar.gz: 4b76bdfa275a1641d782ef84bc96e5e6658d866fb4aef3831f82986dabea510a4e61becb19179bf6a80535181b2492bd939346da8e53c7c110fd36940f181cf7
+  metadata.gz: ef92d06893d7b9a1e56ade70c4b78432c0cd3b04544db92c5827865883d97b9912fc392930e53d26324c6bb6dbec23481e101fb4ba0218c51a2e52ef1634c497
+  data.tar.gz: 24c4313891e0864b95695af807eca5586739c997039cc3bb54b82050964af2dbd92806c90b3e7077d8acdd93f5b636dd306e6300331961b41ef71d424f8a099a

data/app/services/worker_plugins/add_query.rb

@@ -8,17 +8,11 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
   end
 
   def perform
-    created # Cache which are about to be created
-    add_query_to_workplace
-    succeed!(created:)
+    succeed!(affected_count: add_query_to_workplace)
   end
 
   def add_query_to_workplace
-    WorkerPlugins::WorkplaceLink.connection.execute(sql)
-  end
-
-  def created
-    @created ||= resources_to_add.pluck(primary_key.to_sym)
+    WorkerPlugins::WorkplaceLink.connection.exec_update(sql, "WorkerPlugins::AddQuery INSERT", [])
   end
 
   def ids_added_already_query
@@ -40,19 +34,25 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
   end
 
   def primary_key
-    @primary_key ||= resources_to_add.klass.primary_key
+    @primary_key ||= model_class.primary_key
   end
 
   def resources_to_add
-    # Correlate per row with NOT EXISTS instead of NOT IN + a materialized
-    # subquery. The old form expanded into a nested `resource_id IN (SELECT
-    # CAST(users.id AS CHAR) FROM users)` that did a full scan of the target
-    # table when the outer query was unfiltered — 60s+ on 340k+ users. This
-    # uses the `(workplace_id, resource_type, resource_id)` composite index
-    # for an index seek per row.
-    @resources_to_add ||= query
-      .distinct
-      .where("NOT EXISTS (#{existing_workplace_link_exists_sql})")
+    # The unique index on `(workplace_id, resource_type, resource_id)` lets us
+    # skip the `WHERE NOT EXISTS` anti-join for the common unbounded query —
+    # duplicates are rejected on INSERT by the dialect-specific conflict
+    # clause in #sql. `.distinct` still handles same-row duplicates produced
+    # by joins in the caller's query (e.g. `User.joins(:tasks)`).
+    #
+    # When the caller scopes with `.limit` / `.offset`, we keep the anti-join
+    # so already-linked rows are filtered *before* the window is applied;
+    # otherwise `Task.limit(100)` could insert fewer than 100 new rows when
+    # some of those 100 are already linked.
+    @resources_to_add ||= if query.limit_value || query.offset_value
+      query.distinct.where("NOT EXISTS (#{existing_workplace_link_exists_sql})")
+    else
+      query.distinct
+    end
   end
 
   def existing_workplace_link_exists_sql
@@ -106,7 +106,7 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
 
   def sql
     @sql ||= "
-      INSERT INTO
+      #{insert_clause} INTO
         worker_plugins_workplace_links
 
       (
@@ -118,6 +118,23 @@ class WorkerPlugins::AddQuery < WorkerPlugins::ApplicationService
       )
 
       #{select_sql}
+      #{conflict_clause}
     "
   end
+
+  def insert_clause
+    if mysql?
+      "INSERT IGNORE"
+    elsif sqlite?
+      "INSERT OR IGNORE"
+    else
+      "INSERT"
+    end
+  end
+
+  def conflict_clause
+    return "" unless postgres?
+
+    "ON CONFLICT (workplace_id, resource_type, resource_id) DO NOTHING"
+  end
 end

data/app/services/worker_plugins/remove_query.rb

@@ -1,17 +1,37 @@
 class WorkerPlugins::RemoveQuery < WorkerPlugins::ApplicationService
   arguments :query, :workplace
 
-  attr_reader :destroyed
-
   def perform
-    remove_query_from_workplace
-    succeed!(destroyed:, mode: :destroyed)
+    succeed!(affected_count: links_scope.delete_all)
+  end
+
+  def links_scope
+    scope = workplace.workplace_links.where(resource_type: model_class.name)
+    return scope if unscoped_query?
+
+    scope.where(resource_id: query_with_selected_ids)
   end
 
-  def remove_query_from_workplace
-    links_query = workplace.workplace_links.where(resource_type: model_class.name, resource_id: query_with_selected_ids)
-    @destroyed = links_query.pluck(:resource_id)
-    links_query.delete_all
+  # If the caller's query has no meaningful scoping applied, the `resource_id
+  # IN (SELECT ... FROM <target_table>)` subquery would simply materialize
+  # every row of the target model — for 340k+ users that's a full-table scan
+  # with no semantic effect other than preserving orphaned links. The
+  # `resource_type = ?` filter alone is enough to pin the DELETE to this
+  # workplace's links of the given type, so we short-circuit the subquery in
+  # that case. Orphaned links (whose resource row has since been deleted) are
+  # deleted alongside live ones, which matches caller intent ("remove
+  # everything matching the query") and is the correct thing to do with
+  # dead references anyway.
+  def unscoped_query?
+    @query.where_clause.empty? &&
+      @query.joins_values.empty? &&
+      @query.left_outer_joins_values.empty? &&
+      @query.group_values.empty? &&
+      @query.having_clause.empty? &&
+      @query.limit_value.nil? &&
+      @query.offset_value.nil? &&
+      @query.from_clause.value.nil? &&
+      @query.with_values.empty?
   end
 
   def model_class

data/app/services/worker_plugins/select_column_with_type_cast.rb

@@ -46,14 +46,24 @@ class WorkerPlugins::SelectColumnWithTypeCast < WorkerPlugins::ApplicationServic
   end
 
   def same_type?
-    column_to_select.type == column_to_compare_with.type || mysql_string_uuid_compatible_types?
+    return true if column_to_select.type == column_to_compare_with.type
+
+    mysql_implicit_conversion_safe?
   end
 
-  def mysql_string_uuid_compatible_types?
+  # On MySQL / MariaDB, implicit conversion handles comparisons between any
+  # string-ish column types (VARCHAR, CHAR, BINARY, UUID, or types AR doesn't
+  # recognize — e.g. MariaDB's native UUID type when using an older mysql2
+  # adapter). The explicit CAST is only needed when one side is numeric,
+  # because MySQL would then force a string → number conversion that loses
+  # rows containing non-numeric values.
+  def mysql_implicit_conversion_safe?
     return false unless mysql?
 
-    types = [column_to_select.type, column_to_compare_with.type]
+    !numeric_type?(column_to_select.type) && !numeric_type?(column_to_compare_with.type)
+  end
 
-    types.include?(:string) && types.include?(:uuid)
+  def numeric_type?(type)
+    %i[integer decimal float bigint].include?(type)
   end
 end

data/app/services/worker_plugins/switch_query.rb

@@ -2,20 +2,30 @@ class WorkerPlugins::SwitchQuery < WorkerPlugins::ApplicationService
   arguments :query, :workplace
 
   def perform
-    add_query_service = WorkerPlugins::AddQuery.new(query:, workplace:)
-    created = add_query_service.created
-
-    if created.empty?
-      result = WorkerPlugins::RemoveQuery.execute!(query:, workplace:)
-      succeed!(
-        destroyed: result.fetch(:destroyed),
-        mode: :destroyed
-      )
+    # Decide mode *before* running the insert. Deciding it from AddQuery's
+    # post-insert `affected_count` would make concurrent "add" toggles
+    # destructive: if request A's INSERT commits first, overlapping
+    # request B would see `affected_count == 0` from its own (no-op)
+    # INSERT and flip to RemoveQuery, wiping out what A just added. A
+    # pre-insert EXISTS probe keeps the race window small in the same
+    # way the previous candidate-pluck approach did, without materializing
+    # any ids into Ruby.
+    if any_unlinked_candidate?
+      add_result = WorkerPlugins::AddQuery.execute!(query:, workplace:)
+      succeed!(affected_count: add_result.fetch(:affected_count), mode: :created)
     else
-      succeed!(
-        created: add_query_service.tap(&:add_query_to_workplace).created,
-        mode: :created
-      )
+      remove_result = WorkerPlugins::RemoveQuery.execute!(query:, workplace:)
+      succeed!(affected_count: remove_result.fetch(:affected_count), mode: :destroyed)
     end
   end
+
+  def any_unlinked_candidate?
+    add_service = WorkerPlugins::AddQuery.new(query:, workplace:)
+
+    add_service
+      .query
+      .distinct
+      .where("NOT EXISTS (#{add_service.existing_workplace_link_exists_sql})")
+      .exists?
+  end
 end

data/lib/worker_plugins/version.rb

@@ -1,3 +1,3 @@
 module WorkerPlugins
-  VERSION = "0.0.14".freeze
+  VERSION = "0.0.15".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_plugins
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Kasper Stöckel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-22 00:00:00.000000000 Z
+date: 2026-04-23 00:00:00.000000000 Z
 dependencies: []
 description: Rails framework for easily choosing and creating lists of objects and
   execute plugins against them.