umbrellio-sequel-plugins 0.17.2 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a04b57476dd8a38bb6ba7a40a38603ce3dfa807f0a8072c76f4446081b48f97e
-  data.tar.gz: 89fc7a911c67c32321cb0290b5a408effaf948717f0d60ceaa5437c8f7718006
+  metadata.gz: f247c8695f1d06e2ada379cf25e1b387871ff0249816099ff9dd9aaebec32fc8
+  data.tar.gz: 12cc3acf1bb7106fd70a8e4d89ba243e09c766316e2cdd60297e67f3bfafd887
 SHA512:
-  metadata.gz: 4bdbfa1d179d94da6b41d8f1f17556ec1617d420f23c91a0d84d4cc1e3d56b5bb63500018f482ecb92ff459737e62f3692190a3932f7006c505de182deb6b0e2
-  data.tar.gz: 4fd0e9eaa31182ed0df4c7c4c7afa32d231f2d89b59621399558fce7145553889cfc784ba02a13f4c1ff50a6453c002d5d1e5e24435f916b3bc425eae2293d77
+  metadata.gz: 90bf1d35960c9464c3a55e045e91952d0722fd189102e3d4f7b2890cc7c5942ed97f98c4c9000c24f4ed30f44cc2f7c05223ca8f43a6af30253baba48bc9ae28
+  data.tar.gz: a8f770ea411c1dc6688c0136d67106652f08c836f3fb2622a10200d02cae90345cb013ece33577010a41a08dcf55ca34152ec1522bf147956caf41787cdc981d

data/.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3"]
+        ruby: ["3.3", "3.4"]
 
     name: ${{ matrix.ruby }}
 

data/.github/workflows/release.yml

@@ -0,0 +1,54 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract version
+        id: version
+        run: |
+          version=$(grep -oP '(?<=version = ")[^"]+' umbrellio-sequel-plugins.gemspec)
+          echo "tag=v$version" >> "$GITHUB_OUTPUT"
+
+      - name: Check if release already exists
+        id: check
+        run: |
+          if gh release view "${{ steps.version.outputs.tag }}" &>/dev/null; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: ruby/setup-ruby@v1
+        if: steps.check.outputs.exists == 'false'
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - name: Build gem
+        if: steps.check.outputs.exists == 'false'
+        run: gem build umbrellio-sequel-plugins.gemspec
+
+      - name: Push gem to RubyGems
+        if: steps.check.outputs.exists == 'false'
+        run: gem push *.gem
+        env:
+          GEM_HOST_API_KEY: ${{ secrets.GEM_HOST_API_KEY }}
+
+      - uses: softprops/action-gh-release@v3
+        if: steps.check.outputs.exists == 'false'
+        with:
+          tag_name: ${{ steps.version.outputs.tag }}
+          files: "*.gem"
+          generate_release_notes: true

data/.rubocop.yml

@@ -3,7 +3,7 @@ inherit_gem:
 
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.3
 
 Naming/FileName:
   Exclude:

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 
 gem "async"
 gem "money"
+gem "opentelemetry-api"
 gem "pg"
 gem "pry"
 gem "rake"

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    umbrellio-sequel-plugins (0.17.2)
+    umbrellio-sequel-plugins (0.19.0)
+      concurrent-ruby
       sequel
 
 GEM
@@ -40,12 +41,15 @@ GEM
       concurrent-ruby (~> 1.0)
     json (2.7.2)
     language_server-protocol (3.17.0.3)
+    logger (1.7.0)
     method_source (1.1.0)
     minitest (5.25.1)
     money (6.19.0)
       i18n (>= 0.6.4, <= 2)
     mutex_m (0.2.0)
     nio4r (2.7.3)
+    opentelemetry-api (1.10.0)
+      logger
     parallel (1.26.3)
     parser (3.3.5.0)
       ast (~> 2.4.1)
@@ -139,6 +143,7 @@ PLATFORMS
 DEPENDENCIES
   async
   money
+  opentelemetry-api
   pg
   pry
   rake

data/lib/clickhouse/migrator.rb

@@ -18,13 +18,13 @@ module Clickhouse
       migrator(target: target.to_i).run
     end
 
-    def migrator(**opts)
+    def migrator(**)
       Sequel::TimestampMigrator.new(
         DB,
         Rails.root.join("db/migrate/clickhouse"),
         table: :clickhouse_migrations,
         use_transactions: false,
-        **opts,
+        **,
       )
     end
   end

data/lib/sequel/extensions/concurrent_thread_pool.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Sequel
+  # https://github.com/jeremyevans/sequel/blob/master/lib/sequel/extensions/async_thread_pool.rb
+  module Database::ConcurrentThreadPool
+    # Base proxy: delegates all method calls to the resolved async value.
+    class BaseProxy < BasicObject
+      def method_missing(...)
+        __value.public_send(...)
+      end
+
+      def respond_to_missing?(*)
+        __value.respond_to?(*)
+      end
+
+      [:!, :==, :!=, :instance_eval, :instance_exec].each do |method|
+        define_method(method) do |*args, &block|
+          __value.public_send(method, *args, &block)
+        end
+      end
+    end
+
+    # Default proxy: schedules block via Concurrent::Future, blocks on first access.
+    class Proxy < BaseProxy
+      def initialize(executor, &)
+        super()
+
+        @future = Concurrent::Promises.future_on(executor, &)
+      end
+
+      def __value
+        @future.value!
+      end
+    end
+
+    # Preemptable proxy: calling thread runs the block if the pool hasn't started it yet.
+    class PreemptableProxy < BaseProxy
+      def initialize(executor, &block)
+        super()
+
+        @mutex = Mutex.new
+        @block = block
+        @done = false
+        @result = nil
+        @error = nil
+
+        executor.post { __run }
+      end
+
+      def __value
+        error, result = @mutex.synchronize do
+          __execute unless @done
+          [@error, @result]
+        end
+        ::Kernel.raise error if error
+        result
+      end
+
+      private
+
+      def __run
+        @mutex.synchronize { __execute unless @done }
+      end
+
+      def __execute
+        @result = @block.call
+      rescue StandardError => error
+        @error = error
+      ensure
+        @done = true
+      end
+    end
+
+    module DatabaseMethods
+      class << self
+        def make_finalizer(executor) = proc { executor.shutdown }
+
+        def extended(db)
+          db.instance_exec do
+            case pool.pool_type
+            when :single, :sharded_single
+              raise Error, "cannot load concurrent_thread_pool extension " \
+                           "if using single or sharded_single connection pool"
+            end
+
+            executor, owned = choose_executor(opts)
+            proxy_klass =
+              typecast_value_boolean(opts[:preempt_async_thread]) ? PreemptableProxy : Proxy
+
+            define_singleton_method(:async_job_class) { proxy_klass }
+            define_singleton_method(:async_thread_executor) { executor }
+
+            finalizer =
+              Sequel::Database::ConcurrentThreadPool::DatabaseMethods.make_finalizer(executor)
+            ObjectSpace.define_finalizer(db, finalizer) if owned
+
+            extend_datasets(DatasetMethods)
+          end
+        end
+      end
+
+      private
+
+      def choose_executor(opts)
+        if opts[:async_thread_executor]
+          [opts[:async_thread_executor], false]
+        else
+          num = opts[:num_async_threads] ? typecast_value_integer(opts[:num_async_threads]) :
+                                Integer(opts[:max_connections] || 4)
+          raise Error, "must have positive number for num_async_threads" if num <= 0
+          [Concurrent::ThreadPoolExecutor.new(
+            min_threads: num,
+            max_threads: num,
+            max_queue: 0,
+            fallback_policy: :abort,
+          ), true]
+        end
+      end
+
+      def async_run(&)
+        otel_context = OpenTelemetry::Context.current if defined?(OpenTelemetry::Context)
+
+        if otel_context && !otel_context.equal?(OpenTelemetry::Context::ROOT)
+          async_job_class.new(async_thread_executor) do
+            OpenTelemetry::Context.with_current(otel_context, &)
+          end
+        else
+          async_job_class.new(async_thread_executor, &)
+        end
+      end
+    end
+
+    ASYNC_METHODS = ((
+      [:all?, :any?, :drop, :entries, :grep_v, :include?, :inject, :member?, :minmax,
+       :none?, :one?, :reduce, :sort, :take, :tally, :to_a, :to_h, :uniq, :zip] &
+        Enumerable.instance_methods
+    ) + (Dataset::ACTION_METHODS - [:map, :paged_each])).freeze
+
+    ASYNC_BLOCK_METHODS = ((
+      [:collect, :collect_concat, :detect, :drop_while, :each_cons, :each_entry, :each_slice,
+       :each_with_index, :each_with_object, :filter_map, :find, :find_all, :find_index,
+       :flat_map, :max_by, :min_by, :minmax_by, :partition, :reject, :reverse_each,
+       :sort_by, :take_while] & Enumerable.instance_methods
+    ) + [:paged_each]).freeze
+
+    ASYNC_ARGS_OR_BLOCK_METHODS = [:map].freeze
+
+    module DatasetMethods
+      def self.define_async_method(mod, method)
+        mod.send(:define_method, method) do |*args, &block|
+          if @opts[:async]
+            ds = sync
+            db.send(:async_run) { ds.send(method, *args, &block) }
+          else
+            super(*args, &block)
+          end
+        end
+      end
+
+      def self.define_async_block_method(mod, method)
+        mod.send(:define_method, method) do |*args, &block|
+          if block && @opts[:async]
+            ds = sync
+            db.send(:async_run) { ds.send(method, *args, &block) }
+          else
+            super(*args, &block)
+          end
+        end
+      end
+
+      def self.define_async_args_or_block_method(mod, method)
+        mod.send(:define_method, method) do |*args, &block|
+          if (block || !args.empty?) && @opts[:async]
+            ds = sync
+            db.send(:async_run) { ds.send(method, *args, &block) }
+          else
+            super(*args, &block)
+          end
+        end
+      end
+
+      ASYNC_METHODS.each { |m| define_async_method(self, m) }
+      ASYNC_BLOCK_METHODS.each { |m| define_async_block_method(self, m) }
+      ASYNC_ARGS_OR_BLOCK_METHODS.each { |m| define_async_args_or_block_method(self, m) }
+
+      def async
+        cached_dataset(:_async) { clone(async: true) }
+      end
+
+      def sync
+        cached_dataset(:_sync) { clone(async: false) }
+      end
+    end
+  end
+
+  Database.register_extension(
+    :concurrent_thread_pool, Database::ConcurrentThreadPool::DatabaseMethods
+  )
+end

data/lib/sequel/extensions/migration_transaction_options.rb

@@ -11,9 +11,9 @@ module SimpleMigrationExtension
 end
 
 module MigratorExtension
-  def checked_transaction(migration, &block)
+  def checked_transaction(migration, &)
     if _use_transaction?(migration)
-      _transaction(migration, &block)
+      _transaction(migration, &)
     else
       yield
     end
@@ -38,11 +38,11 @@ module MigratorExtension
     end
   end
 
-  def _transaction(migration, &block)
+  def _transaction(migration, &)
     if migration.transaction_opts.nil?
-      db.transaction(&block)
+      db.transaction(&)
     else
-      db.transaction(migration.transaction_opts, &block)
+      db.transaction(migration.transaction_opts, &)
     end
   end
 end

data/lib/sequel/extensions/synchronize.rb

@@ -24,9 +24,9 @@ module Sequel
     def synchronize_with(*args, timeout: 10, savepoint: false, skip_if_locked: false)
       key = lock_key_for(args)
 
-      transaction(savepoint: savepoint) do
+      transaction(savepoint:) do
         hash = key_hash(key)
-        if get_lock(key, hash, timeout: timeout, skip_if_locked: skip_if_locked)
+        if get_lock(key, hash, timeout:, skip_if_locked:)
           log_info("locked with #{key} (#{hash})")
           yield
         end

data/lib/sequel/plugins/concurrent_thread_pool_eager_loading.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Sequel
+  module Plugins
+    # Concurrent eager loading using concurrent_thread_pool extension.
+    # Adapted from Sequel's built-in concurrent_eager_loading plugin but uses
+    # our concurrent_thread_pool extension instead of async_thread_pool.
+    #
+    # Usage:
+    #
+    #   DB.extension(:concurrent_thread_pool)
+    #   Album.plugin :concurrent_thread_pool_eager_loading
+    #   Album.eager_load_concurrently.eager(:artist, :genre, :tracks).all
+    #
+    #   # Always concurrent by default:
+    #   Album.plugin :concurrent_thread_pool_eager_loading, always: true
+    module ConcurrentThreadPoolEagerLoading
+      def self.configure(mod, opts = OPTS)
+        if opts.key?(:always)
+          mod.instance_variable_set(:@always_eager_load_concurrently, opts[:always])
+        end
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@always_eager_load_concurrently => nil)
+        Plugins.def_dataset_methods(self, [:eager_load_concurrently, :eager_load_serially])
+
+        def always_eager_load_concurrently?
+          @always_eager_load_concurrently
+        end
+      end
+
+      module DatasetMethods
+        def eager_load_concurrently
+          cached_dataset(:_eager_load_concurrently) do
+            clone(eager_load_concurrently: true)
+          end
+        end
+
+        def eager_load_serially
+          cached_dataset(:_eager_load_serially) do
+            clone(eager_load_concurrently: false)
+          end
+        end
+
+        private
+
+        def eager_load_concurrently?
+          v = @opts[:eager_load_concurrently]
+          v.nil? ? model.always_eager_load_concurrently? : v
+        end
+
+        def perform_eager_loads(eager_load_data)
+          return super if !eager_load_concurrently? || eager_load_data.length < 2
+
+          mutex = Mutex.new
+          eager_load_data.each_value do |elo|
+            elo[:mutex] = mutex
+          end
+
+          super.each do |v|
+            if Sequel::Database::ConcurrentThreadPool::BaseProxy === v # rubocop:disable Style/CaseEquality
+              v.__value
+            end
+          end
+        end
+
+        def perform_eager_load(loader, elo)
+          elo[:mutex] ? db.send(:async_run) { super } : super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/upsert.rb

@@ -16,7 +16,7 @@ module Sequel::Plugins::Upsert
       where_spec = cols.map { |x| Sequel::Plugins::Upsert.distinct_expr(table_name, x) }.reduce(:|)
 
       dataset.insert_conflict(
-        target: target,
+        target:,
         update: update_spec,
         update_where: where_spec,
       )
@@ -25,21 +25,21 @@ module Sequel::Plugins::Upsert
     # Executes the upsert request
     #
     # @param row [Hash] values
-    # @param options [Hash] options
+    # @param target [Symbol] target column
     #
     # @example
-    #   User.upsert(name: "John", email: "jd@test.com", target: :email)
+    #   User.upsert({name: "John", email: "jd@test.com"}, target: :email)
     # @return [Sequel::Model]
-    def upsert(row, **options)
-      upsert_dataset(**options).insert(sequel_values(row))
+    def upsert(row, **)
+      upsert_dataset(**).insert(sequel_values(row))
     end
 
     # Executes the upsert request for multiple rows
     # @see #upsert
     # @see #upsert_dataset
-    def multi_upsert(rows, **options)
+    def multi_upsert(rows, **)
       rows = rows.map { |row| sequel_values(row) }
-      upsert_dataset(**options).multi_insert(rows)
+      upsert_dataset(**).multi_insert(rows)
     end
 
     # Returns formatted row values

data/lib/sequel/plugins/with_lock.rb

@@ -10,7 +10,7 @@ module Sequel::Plugins::WithLock
       @__locked = true
 
       begin
-        db.transaction(savepoint: savepoint) do
+        db.transaction(savepoint:) do
           lock!(mode)
           yield
         end

data/lib/tasks/sequel/archive_migrations.rake

@@ -15,7 +15,7 @@ namespace :sequel do
 
     migrations = Rails.root.glob(migrations_path).map do |file|
       filename = file.basename.to_s
-      { version: filename.to_i, filename: filename, source: file.read }
+      { version: filename.to_i, filename:, source: file.read }
     end
 
     conflict_options = {

data/lib/tasks/sequel/rollback_archived_migrations.rake

@@ -21,7 +21,7 @@ namespace :sequel do
 
       migrator_args = {
         table: args[:migration_table],
-        use_transactions: use_transactions,
+        use_transactions:,
         allow_missing_migration_files: false,
       }.compact
       migrator = Sequel::TimestampMigrator.new(DB, tmpdir, migrator_args)

data/lib/tasks/sequel/rollback_missing_migrations.rake

@@ -23,7 +23,7 @@ namespace :sequel do
     path = Rails.root.join("db/migrate")
     migrator_args = {
       table: args[:table],
-      use_transactions: use_transactions,
+      use_transactions:,
       allow_missing_migration_files: false,
     }.compact
     migrator = Sequel::TimestampMigrator.new(DB, path, migrator_args)

data/umbrellio-sequel-plugins.gemspec

@@ -5,8 +5,8 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name = "umbrellio-sequel-plugins"
-  spec.version = "0.17.2"
-  spec.required_ruby_version = ">= 3.0"
+  spec.version = "0.19.0"
+  spec.required_ruby_version = ">= 3.3"
 
   spec.authors = ["Team Umbrellio"]
   spec.email = ["oss@umbrellio.biz"]
@@ -18,5 +18,6 @@ Gem::Specification.new do |spec|
   spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency "concurrent-ruby"
   spec.add_runtime_dependency "sequel"
 end

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: umbrellio-sequel-plugins
 version: !ruby/object:Gem::Version
-  version: 0.17.2
+  version: 0.19.0
 platform: ruby
 authors:
 - Team Umbrellio
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -32,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -43,6 +57,7 @@ files:
 - bin/console
 - bin/setup
 - lib/clickhouse/migrator.rb
+- lib/sequel/extensions/concurrent_thread_pool.rb
 - lib/sequel/extensions/currency_rates.rb
 - lib/sequel/extensions/deferrable_foreign_keys.rb
 - lib/sequel/extensions/fibered_connection_pool.rb
@@ -54,6 +69,7 @@ files:
 - lib/sequel/extensions/synchronize.rb
 - lib/sequel/plugins/attr_encrypted.rb
 - lib/sequel/plugins/attr_encrypted/simple_crypt.rb
+- lib/sequel/plugins/concurrent_thread_pool_eager_loading.rb
 - lib/sequel/plugins/duplicate.rb
 - lib/sequel/plugins/get_column_value.rb
 - lib/sequel/plugins/money_accessors.rb
@@ -77,7 +93,6 @@ homepage: https://github.com/umbrellio/umbrellio-sequel-plugins
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -85,15 +100,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Sequel plugins
 test_files: []