tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.0.4/lib/active_record/insert_all.rb

@@ -1,328 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/enumerable"
-
-module ActiveRecord
-  class InsertAll # :nodoc:
-    attr_reader :model, :connection, :inserts, :keys
-    attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
-
-    class << self
-      def execute(relation, ...)
-        relation.model.with_connection do |c|
-          new(relation, c, ...).execute
-        end
-      end
-    end
-
-    def initialize(relation, connection, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
-      @relation = relation
-      @model, @connection, @inserts = relation.model, connection, inserts.map(&:stringify_keys)
-      @on_duplicate, @update_only, @returning, @unique_by = on_duplicate, update_only, returning, unique_by
-      @record_timestamps = record_timestamps.nil? ? model.record_timestamps : record_timestamps
-
-      disallow_raw_sql!(on_duplicate)
-      disallow_raw_sql!(returning)
-
-      if @inserts.empty?
-        @keys = []
-      else
-        resolve_sti
-        resolve_attribute_aliases
-        @keys = @inserts.first.keys
-      end
-
-      @scope_attributes = relation.scope_for_create.except(@model.inheritance_column)
-      @keys |= @scope_attributes.keys
-      @keys = @keys.to_set
-
-      @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
-      @returning = false if @returning == []
-
-      @unique_by = find_unique_index_for(@unique_by)
-
-      configure_on_duplicate_update_logic
-      ensure_valid_options_for_connection!
-    end
-
-    def execute
-      return ActiveRecord::Result.empty if inserts.empty?
-
-      message = +"#{model} "
-      message << "Bulk " if inserts.many?
-      message << (on_duplicate == :update ? "Upsert" : "Insert")
-      connection.exec_insert_all to_sql, message
-    end
-
-    def updatable_columns
-      @updatable_columns ||= keys - readonly_columns - unique_by_columns
-    end
-
-    def primary_keys
-      Array(@model.schema_cache.primary_keys(model.table_name))
-    end
-
-    def skip_duplicates?
-      on_duplicate == :skip
-    end
-
-    def update_duplicates?
-      on_duplicate == :update
-    end
-
-    def map_key_with_value
-      inserts.map do |attributes|
-        attributes = attributes.stringify_keys
-        attributes.merge!(@scope_attributes)
-        attributes.reverse_merge!(timestamps_for_create) if record_timestamps?
-
-        verify_attributes(attributes)
-
-        keys_including_timestamps.map do |key|
-          yield key, attributes[key]
-        end
-      end
-    end
-
-    def record_timestamps?
-      @record_timestamps
-    end
-
-    # TODO: Consider renaming this method, as it only conditionally extends keys, not always
-    def keys_including_timestamps
-      @keys_including_timestamps ||= if record_timestamps?
-        keys + model.all_timestamp_attributes_in_model
-      else
-        keys
-      end
-    end
-
-    private
-      def has_attribute_aliases?(attributes)
-        attributes.keys.any? { |attribute| model.attribute_alias?(attribute) }
-      end
-
-      def resolve_sti
-        return if model.descends_from_active_record?
-
-        sti_type = model.sti_name
-        @inserts = @inserts.map do |insert|
-          insert.reverse_merge(model.inheritance_column.to_s => sti_type)
-        end
-      end
-
-      def resolve_attribute_aliases
-        return unless has_attribute_aliases?(@inserts.first)
-
-        @inserts = @inserts.map do |insert|
-          insert.transform_keys { |attribute| resolve_attribute_alias(attribute) }
-        end
-
-        @update_only = Array(@update_only).map { |attribute| resolve_attribute_alias(attribute) } if @update_only
-        @unique_by = Array(@unique_by).map { |attribute| resolve_attribute_alias(attribute) } if @unique_by
-      end
-
-      def resolve_attribute_alias(attribute)
-        model.attribute_alias(attribute) || attribute
-      end
-
-      def configure_on_duplicate_update_logic
-        if custom_update_sql_provided? && update_only.present?
-          raise ArgumentError, "You can't set :update_only and provide custom update SQL via :on_duplicate at the same time"
-        end
-
-        if update_only.present?
-          @updatable_columns = Array(update_only)
-          @on_duplicate = :update
-        elsif custom_update_sql_provided?
-          @update_sql = on_duplicate
-          @on_duplicate = :update
-        elsif @on_duplicate == :update && updatable_columns.empty?
-          @on_duplicate = :skip
-        end
-      end
-
-      def custom_update_sql_provided?
-        @custom_update_sql_provided ||= Arel.arel_node?(on_duplicate)
-      end
-
-      def find_unique_index_for(unique_by)
-        if !connection.supports_insert_conflict_target?
-          return if unique_by.nil?
-
-          raise ArgumentError, "#{connection.class} does not support :unique_by"
-        end
-
-        name_or_columns = unique_by || model.primary_key
-        match = Array(name_or_columns).map(&:to_s)
-        sorted_match = match.sort
-
-        if index = unique_indexes.find { |i| match.include?(i.name) || Array(i.columns).sort == sorted_match }
-          index
-        elsif match == primary_keys
-          unique_by.nil? ? nil : ActiveRecord::ConnectionAdapters::IndexDefinition.new(model.table_name, "#{model.table_name}_primary_key", true, match)
-        else
-          raise ArgumentError, "No unique index found for #{name_or_columns}"
-        end
-      end
-
-      def unique_indexes
-        @model.schema_cache.indexes(model.table_name).select(&:unique)
-      end
-
-      def ensure_valid_options_for_connection!
-        if returning && !connection.supports_insert_returning?
-          raise ArgumentError, "#{connection.class} does not support :returning"
-        end
-
-        if skip_duplicates? && !connection.supports_insert_on_duplicate_skip?
-          raise ArgumentError, "#{connection.class} does not support skipping duplicates"
-        end
-
-        if update_duplicates? && !connection.supports_insert_on_duplicate_update?
-          raise ArgumentError, "#{connection.class} does not support upsert"
-        end
-
-        if unique_by && !connection.supports_insert_conflict_target?
-          raise ArgumentError, "#{connection.class} does not support :unique_by"
-        end
-      end
-
-
-      def to_sql
-        connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(self))
-      end
-
-
-      def readonly_columns
-        primary_keys + model.readonly_attributes
-      end
-
-      def unique_by_columns
-        Array(unique_by&.columns)
-      end
-
-
-      def verify_attributes(attributes)
-        if keys_including_timestamps != attributes.keys.to_set
-          raise ArgumentError, "All objects being inserted must have the same keys"
-        end
-      end
-
-      def disallow_raw_sql!(value)
-        return if !value.is_a?(String) || Arel.arel_node?(value)
-
-        raise ArgumentError, "Dangerous query method (method whose arguments are used as raw " \
-                             "SQL) called: #{value}. " \
-                             "Known-safe values can be passed " \
-                             "by wrapping them in Arel.sql()."
-      end
-
-      def timestamps_for_create
-        model.all_timestamp_attributes_in_model.index_with(connection.high_precision_current_timestamp)
-      end
-
-      class Builder # :nodoc:
-        attr_reader :model
-
-        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, to: :insert_all
-
-        def initialize(insert_all)
-          @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
-        end
-
-        def into
-          "INTO #{model.quoted_table_name} (#{columns_list})"
-        end
-
-        def values_list
-          types = extract_types_from_columns_on(model.table_name, keys: keys_including_timestamps)
-
-          values_list = insert_all.map_key_with_value do |key, value|
-            next value if Arel::Nodes::SqlLiteral === value
-            ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
-          end
-
-          connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
-        end
-
-        def returning
-          return unless insert_all.returning
-
-          if insert_all.returning.is_a?(String)
-            insert_all.returning
-          else
-            Array(insert_all.returning).map do |attribute|
-              if model.attribute_alias?(attribute)
-                "#{quote_column(model.attribute_alias(attribute))} AS #{quote_column(attribute)}"
-              else
-                quote_column(attribute)
-              end
-            end.join(",")
-          end
-        end
-
-        def conflict_target
-          if index = insert_all.unique_by
-            sql = +"(#{format_columns(index.columns)})"
-            sql << " WHERE #{index.where}" if index.where
-            sql
-          elsif update_duplicates?
-            "(#{format_columns(insert_all.primary_keys)})"
-          end
-        end
-
-        def updatable_columns
-          quote_columns(insert_all.updatable_columns)
-        end
-
-        def touch_model_timestamps_unless(&block)
-          return "" unless update_duplicates? && record_timestamps?
-
-          model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
-            if touch_timestamp_attribute?(column_name)
-              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE #{connection.high_precision_current_timestamp} END),"
-            end
-          end.join
-        end
-
-        def raw_update_sql
-          insert_all.update_sql
-        end
-
-        alias raw_update_sql? raw_update_sql
-
-        private
-          attr_reader :connection, :insert_all
-
-          def touch_timestamp_attribute?(column_name)
-            insert_all.updatable_columns.exclude?(column_name)
-          end
-
-          def columns_list
-            format_columns(insert_all.keys_including_timestamps)
-          end
-
-          def extract_types_from_columns_on(table_name, keys:)
-            columns = @model.schema_cache.columns_hash(table_name)
-
-            unknown_column = (keys - columns.keys).first
-            raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column
-
-            keys.index_with { |key| model.type_for_attribute(key) }
-          end
-
-          def format_columns(columns)
-            columns.respond_to?(:map) ? quote_columns(columns).join(",") : columns
-          end
-
-          def quote_columns(columns)
-            columns.map { |column| quote_column(column) }
-          end
-
-          def quote_column(column)
-            connection.quote_column_name(column)
-          end
-      end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.0.4/lib/active_record/locking/optimistic.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Locking
-    # == What is \Optimistic \Locking
-    #
-    # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
-    # conflicts with the data. It does this by checking whether another process has made changes to a record since
-    # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
-    # and the update is ignored.
-    #
-    # Check out ActiveRecord::Locking::Pessimistic for an alternative.
-    #
-    # == Usage
-    #
-    # Active Record supports optimistic locking if the +lock_version+ field is present. Each update to the
-    # record increments the integer column +lock_version+ and the locking facilities ensure that records instantiated twice
-    # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
-    #
-    #   p1 = Person.find(1)
-    #   p2 = Person.find(1)
-    #
-    #   p1.first_name = "Michael"
-    #   p1.save
-    #
-    #   p2.first_name = "should fail"
-    #   p2.save # Raises an ActiveRecord::StaleObjectError
-    #
-    # Optimistic locking will also check for stale data when objects are destroyed. Example:
-    #
-    #   p1 = Person.find(1)
-    #   p2 = Person.find(1)
-    #
-    #   p1.first_name = "Michael"
-    #   p1.save
-    #
-    #   p2.destroy # Raises an ActiveRecord::StaleObjectError
-    #
-    # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
-    # or otherwise apply the business logic needed to resolve the conflict.
-    #
-    # This locking mechanism will function inside a single Ruby process. To make it work across all
-    # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
-    #
-    # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
-    # To override the name of the +lock_version+ column, set the <tt>locking_column</tt> class attribute:
-    #
-    #   class Person < ActiveRecord::Base
-    #     self.locking_column = :lock_person
-    #   end
-    #
-    module Optimistic
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :lock_optimistically, instance_writer: false, default: true
-      end
-
-      def locking_enabled? # :nodoc:
-        self.class.locking_enabled?
-      end
-
-      def increment!(*, **) # :nodoc:
-        super.tap do
-          if locking_enabled?
-            self[self.class.locking_column] += 1
-            clear_attribute_change(self.class.locking_column)
-          end
-        end
-      end
-
-      def initialize_dup(other) # :nodoc:
-        super
-        _clear_locking_column if locking_enabled?
-      end
-
-      private
-        def _create_record(attribute_names = self.attribute_names)
-          if locking_enabled?
-            # We always want to persist the locking version, even if we don't detect
-            # a change from the default, since the database might have no default
-            attribute_names |= [self.class.locking_column]
-          end
-          super
-        end
-
-        def _touch_row(attribute_names, time)
-          @_touch_attr_names << self.class.locking_column if locking_enabled?
-          super
-        end
-
-        def _update_row(attribute_names, attempted_action = "update")
-          return super unless locking_enabled?
-
-          begin
-            locking_column = self.class.locking_column
-            lock_attribute_was = @attributes[locking_column]
-
-            update_constraints = _query_constraints_hash
-
-            attribute_names = attribute_names.dup if attribute_names.frozen?
-            attribute_names << locking_column
-
-            self[locking_column] += 1
-
-            affected_rows = self.class._update_record(
-              attributes_with_values(attribute_names),
-              update_constraints
-            )
-
-            if affected_rows != 1
-              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
-            end
-
-            affected_rows
-
-          # If something went wrong, revert the locking_column value.
-          rescue Exception
-            @attributes[locking_column] = lock_attribute_was
-            raise
-          end
-        end
-
-        def destroy_row
-          affected_rows = super
-
-          if locking_enabled? && affected_rows != 1
-            raise ActiveRecord::StaleObjectError.new(self, "destroy")
-          end
-
-          affected_rows
-        end
-
-        def _lock_value_for_database(locking_column)
-          if will_save_change_to_attribute?(locking_column)
-            @attributes[locking_column].value_for_database
-          else
-            @attributes[locking_column].original_value_for_database
-          end
-        end
-
-        def _clear_locking_column
-          self[self.class.locking_column] = nil
-          clear_attribute_change(self.class.locking_column)
-        end
-
-        def _query_constraints_hash
-          return super unless locking_enabled?
-
-          locking_column = self.class.locking_column
-          super.merge(locking_column => _lock_value_for_database(locking_column))
-        end
-
-        module ClassMethods
-          DEFAULT_LOCKING_COLUMN = "lock_version"
-
-          # Returns true if the +lock_optimistically+ flag is set to true
-          # (which it is, by default) and the table includes the
-          # +locking_column+ column (defaults to +lock_version+).
-          def locking_enabled?
-            lock_optimistically && columns_hash[locking_column]
-          end
-
-          # Set the column to use for optimistic locking. Defaults to +lock_version+.
-          def locking_column=(value)
-            reload_schema_from_cache
-            @locking_column = value.to_s
-          end
-
-          # The version column used for optimistic locking. Defaults to +lock_version+.
-          attr_reader :locking_column
-
-          # Reset the column used for optimistic locking back to the +lock_version+ default.
-          def reset_locking_column
-            self.locking_column = DEFAULT_LOCKING_COLUMN
-          end
-
-          # Make sure the lock version column gets updated when counters are
-          # updated.
-          def update_counters(id, counters)
-            counters = counters.merge(locking_column => 1) if locking_enabled?
-            super
-          end
-
-          private
-            def hook_attribute_type(name, cast_type)
-              if lock_optimistically && name == locking_column
-                cast_type = LockingType.new(cast_type)
-              end
-
-              super
-            end
-
-            def inherited(base)
-              super
-              base.class_eval do
-                @locking_column = DEFAULT_LOCKING_COLUMN
-              end
-            end
-        end
-    end
-
-    # In de/serialize we change `nil` to 0, so that we can allow passing
-    # `nil` values to `lock_version`, and not result in `ActiveRecord::StaleObjectError`
-    # during update record.
-    class LockingType < DelegateClass(Type::Value) # :nodoc:
-      def self.new(subtype)
-        self === subtype ? subtype : super
-      end
-
-      def deserialize(value)
-        super.to_i
-      end
-
-      def serialize(value)
-        super.to_i
-      end
-
-      def init_with(coder)
-        __setobj__(coder["subtype"])
-      end
-
-      def encode_with(coder)
-        coder["subtype"] = __getobj__
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.0.4/lib/active_record/locking/pessimistic.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Locking
-    # = \Pessimistic \Locking
-    #
-    # Locking::Pessimistic provides support for row-level locking using
-    # SELECT ... FOR UPDATE and other lock types.
-    #
-    # Chain <tt>ActiveRecord::Base#find</tt> to ActiveRecord::QueryMethods#lock to obtain an exclusive
-    # lock on the selected rows:
-    #   # select * from accounts where id=1 for update
-    #   Account.lock.find(1)
-    #
-    # Call <tt>lock('some locking clause')</tt> to use a database-specific locking clause
-    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
-    #
-    #   Account.transaction do
-    #     # select * from accounts where name = 'shugo' limit 1 for update nowait
-    #     shugo = Account.lock("FOR UPDATE NOWAIT").find_by(name: "shugo")
-    #     yuko = Account.lock("FOR UPDATE NOWAIT").find_by(name: "yuko")
-    #     shugo.balance -= 100
-    #     shugo.save!
-    #     yuko.balance += 100
-    #     yuko.save!
-    #   end
-    #
-    # You can also use <tt>ActiveRecord::Base#lock!</tt> method to lock one record by id.
-    # This may be better if you don't need to lock every row. Example:
-    #
-    #   Account.transaction do
-    #     # select * from accounts where ...
-    #     accounts = Account.where(...)
-    #     account1 = accounts.detect { |account| ... }
-    #     account2 = accounts.detect { |account| ... }
-    #     # select * from accounts where id=? for update
-    #     account1.lock!
-    #     account2.lock!
-    #     account1.balance -= 100
-    #     account1.save!
-    #     account2.balance += 100
-    #     account2.save!
-    #   end
-    #
-    # You can start a transaction and acquire the lock in one go by calling
-    # <tt>with_lock</tt> with a block. The block is called from within
-    # a transaction, the object is already locked. Example:
-    #
-    #   account = Account.first
-    #   account.with_lock do
-    #     # This block is called within a transaction,
-    #     # account is already locked.
-    #     account.balance -= 100
-    #     account.save!
-    #   end
-    #
-    # Database-specific information on row locking:
-    #
-    # [MySQL]
-    #   https://dev.mysql.com/doc/refman/en/innodb-locking-reads.html
-    #
-    # [PostgreSQL]
-    #   https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
-    module Pessimistic
-      # Obtain a row lock on this record. Reloads the record to obtain the requested
-      # lock. Pass an SQL locking clause to append the end of the SELECT statement
-      # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
-      # the locked record.
-      def lock!(lock = true)
-        if persisted?
-          if has_changes_to_save?
-            raise(<<-MSG.squish)
-              Locking a record with unpersisted changes is not supported. Use
-              `save` to persist the changes, or `reload` to discard them
-              explicitly.
-              Changed attributes: #{changed.map(&:inspect).join(', ')}.
-            MSG
-          end
-
-          reload(lock: lock)
-        end
-        self
-      end
-
-      # Wraps the passed block in a transaction, reloading the object with a
-      # lock before yielding. You can pass the SQL locking clause
-      # as an optional argument (see #lock!).
-      #
-      # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,
-      # and <tt>joinable:</tt> to the wrapping transaction (see
-      # ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction).
-      def with_lock(*args)
-        transaction_opts = args.extract_options!
-        lock = args.present? ? args.first : true
-        transaction(**transaction_opts) do
-          lock!(lock)
-          yield
-        end
-      end
-    end
-  end
-end