rom-sql 3.6.4 → 4.0.0.alpha1

data/lib/rom/sql/relation/reading.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rom/support/inflector'
-require 'rom/sql/join_dsl'
+require "rom/support/inflector"
+require "rom/sql/join_dsl"
 
 module ROM
   module SQL
@@ -11,18 +11,18 @@ module ROM
       # @api public
       module Reading
         # Row-level lock modes
-        ROW_LOCK_MODES = Hash.new({ update: "FOR UPDATE" }).update(
+        ROW_LOCK_MODES = Hash.new(update: "FOR UPDATE").update(
           # https://www.postgresql.org/docs/current/static/sql-select.html#SQL-FOR-UPDATE-SHARE
           postgres: {
-            update: 'FOR UPDATE'.freeze,
-            no_key_update: 'FOR NO KEY UPDATE'.freeze,
-            share: 'FOR SHARE'.freeze,
-            key_share: 'FOR KEY SHARE'.freeze
+            update: "FOR UPDATE",
+            no_key_update: "FOR NO KEY UPDATE",
+            share: "FOR SHARE",
+            key_share: "FOR KEY SHARE"
           },
           # https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
           mysql: {
-            update: 'FOR UPDATE'.freeze,
-            share: 'LOCK IN SHARE MODE'.freeze
+            update: "FOR UPDATE",
+            share: "LOCK IN SHARE MODE"
           }
         ).freeze
 
@@ -235,8 +235,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def select(*args, &block)
-          schema.project(*args, &block).(self)
+        def select(...)
+          schema.project(...).(self)
         end
         alias_method :project, :select
 
@@ -247,8 +247,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def select_append(*args, &block)
-          schema.merge(schema.canonical.project(*args, &block)).(self)
+        def select_append(...)
+          schema.merge(schema.canonical.project(...)).(self)
         end
 
         # Returns a copy of the relation with a SQL DISTINCT clause.
@@ -724,7 +724,7 @@ module ROM
         # @api public
         def group(*args, &block)
           if block
-            if args.size > 0
+            if args.size.positive?
               group(*args).group_append(&block)
             else
               new(dataset.__send__(__method__, *schema.canonical.group(&block)))
@@ -763,7 +763,7 @@ module ROM
         # @api public
         def group_append(*args, &block)
           if block
-            if args.size > 0
+            if args.size.positive?
               group_append(*args).group_append(&block)
             else
               new(dataset.group_append(*schema.canonical.group(&block)))
@@ -814,8 +814,10 @@ module ROM
         #
         # @param [Hash] options Options for union
         # @option options [Symbol] :alias Use the given value as the #from_self alias
-        # @option options [TrueClass, FalseClass] :all Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
-        # @option options [TrueClass, FalseClass] :from_self Set to false to not wrap the returned dataset in a #from_self, use with care.
+        # @option options [TrueClass, FalseClass] :all Set to true to use UNION ALL instead of UNION, so duplicate rows
+        #   can occur
+        # @option options [TrueClass, FalseClass] :from_self Set to false to not wrap the returned dataset in a
+        #   #from_self, use with care.
         #
         # @returRelation]
         #
@@ -827,7 +829,7 @@ module ROM
           # confusing ways.
           same_relation = name == relation.name
           alias_name =  same_relation ? name : "#{name.to_sym}__#{relation.name.to_sym}"
-          opts = { alias: alias_name.to_sym, **options }
+          opts = {alias: alias_name.to_sym, **options}
 
           new_schema = schema.qualified(opts[:alias])
           new_schema.(new(dataset.__send__(__method__, relation.dataset, opts, &block)))
@@ -848,8 +850,8 @@ module ROM
         # @return [TrueClass, FalseClass]
         #
         # @api public
-        def exist?(*args, &block)
-          !where(*args, &block).limit(1).count.zero?
+        def exist?(...)
+          !where(...).limit(1).count.zero?
         end
 
         # Return if a restricted relation has 0 tuples
@@ -958,7 +960,7 @@ module ROM
           pks = schema.primary_key
 
           if pks.size > 1
-            raise ArgumentError, 'Composite primary keys are not supported yet'
+            raise ArgumentError, "Composite primary keys are not supported yet"
           end
 
           source = order(pks[0]).limit(size)
@@ -1047,18 +1049,18 @@ module ROM
         # @api private
         def lock_clause(mode: :update, skip_locked: false, of: nil, wait: nil)
           stmt = ROW_LOCK_MODES[dataset.db.database_type].fetch(mode).dup
-          stmt << ' OF ' << Array(of).join(', ') if of
+          stmt << " OF " << Array(of).join(", ") if of
 
           if skip_locked
-            raise ArgumentError, 'SKIP LOCKED cannot be used with (NO)WAIT clause' if !wait.nil?
+            raise ArgumentError, "SKIP LOCKED cannot be used with (NO)WAIT clause" unless wait.nil?
 
-            stmt << ' SKIP LOCKED'
+            stmt << " SKIP LOCKED"
           else
             case wait
             when Integer
-              stmt << ' WAIT ' << wait.to_s
+              stmt << " WAIT " << wait.to_s
             when false
-              stmt << ' NOWAIT'
+              stmt << " NOWAIT"
             else
               stmt
             end
@@ -1084,6 +1086,9 @@ module ROM
         # Common join method used by other join methods
         #
         # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/PerceivedComplexity
         def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &block)
           if other.is_a?(Symbol) || other.is_a?(ROM::Relation::Name)
             if join_cond.equal?(EMPTY_HASH) && !block
@@ -1101,7 +1106,7 @@ module ROM
               join_cond = JoinDSL.new(schema).(&block)
 
               if other.name.aliaz
-                join_opts = { table_alias: other.name.aliaz }
+                join_opts = {table_alias: other.name.aliaz}
               else
                 join_opts = EMPTY_HASH
               end
@@ -1114,6 +1119,8 @@ module ROM
             raise ArgumentError, "+other+ must be either a symbol or a relation, #{other.class} given"
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/PerceivedComplexity
       end
     end
   end

data/lib/rom/sql/relation/writing.rb

@@ -37,8 +37,8 @@ module ROM
         # @return [Hash] Inserted tuple
         #
         # @api public
-        def insert(*args, &block)
-          dataset.insert(*args, &block)
+        def insert(...)
+          dataset.insert(...)
         end
 
         # Multi insert tuples into relation
@@ -51,8 +51,8 @@ module ROM
         # @return [Array<String>] A list of executed SQL statements
         #
         # @api public
-        def multi_insert(*args, &block)
-          dataset.multi_insert(*args, &block)
+        def multi_insert(...)
+          dataset.multi_insert(...)
         end
 
         # Update tuples in the relation
@@ -64,8 +64,8 @@ module ROM
         # @return [Integer] Number of updated rows
         #
         # @api public
-        def update(*args, &block)
-          dataset.update(*args, &block)
+        def update(...)
+          dataset.update(...)
         end
 
         # Delete tuples from the relation
@@ -78,8 +78,8 @@ module ROM
         # @return [Integer] Number of deleted tuples
         #
         # @api public
-        def delete(*args, &block)
-          dataset.delete(*args, &block)
+        def delete(...)
+          dataset.delete(...)
         end
 
         # Insert tuples from other relation
@@ -113,12 +113,13 @@ module ROM
         #
         # @api public
         def import(other, options = EMPTY_HASH)
+          columns = other.schema.map { |a| a.alias || a.name }
+
           if other.gateway.eql?(gateway)
-            columns = other.schema.map { |a| a.alias || a.name }
             dataset.import(columns, other.dataset, options)
           else
-            columns = other.schema.map { |a| a.alias || a.name }
             keys = columns.map(&:to_sym)
+
             dataset.import(columns, other.to_a.map { |record| record.to_h.values_at(*keys) }, options)
           end
         end

data/lib/rom/sql/relation.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
-require 'rom/sql/types'
-require 'rom/sql/schema'
-require 'rom/sql/attribute'
-require 'rom/sql/wrap'
-require 'rom/sql/transaction'
+require "rom/relation"
 
-require 'rom/sql/relation/reading'
-require 'rom/sql/relation/writing'
+require "rom/sql/types"
+require "rom/sql/schema"
+require "rom/sql/attribute"
+require "rom/sql/wrap"
+require "rom/sql/transaction"
+
+require "rom/sql/relation/reading"
+require "rom/sql/relation/writing"
+require "rom/sql/schema/dsl"
 
 module ROM
   module SQL
@@ -15,90 +18,37 @@ module ROM
     #
     # @api public
     class Relation < ROM::Relation
-      adapter :sql
+      extend Dry::Core::ClassAttributes # TODO: only needed by pagination plugin
 
       include SQL
       include Writing
       include Reading
 
-      extend Notifications::Listener
-
-      schema_class SQL::Schema
-      schema_attr_class SQL::Attribute
-      schema_inferrer ROM::SQL::Schema::Inferrer.new.freeze
-      schema_dsl SQL::Schema::DSL
-      wrap_class SQL::Wrap
-
-      subscribe('configuration.relations.schema.set', adapter: :sql) do |event|
-        schema = event[:schema]
-        relation = event[:relation]
+      config.wrap_class = SQL::Wrap
 
-        relation.dataset do
-          table = opts[:from].first
-
-          if db.table_exists?(table)
-            select(*schema.qualified_projection).order(*schema.project(*schema.primary_key_names).qualified)
-          else
-            self
-          end
-        end
+      configure(:component) do |config|
+        config.adapter = :sql
       end
 
-      subscribe('configuration.relations.dataset.allocated', adapter: :sql) do |event|
-        event[:relation].define_default_views!
+      configure(:schema) do |config|
+        config.constant = SQL::Schema
+        config.attr_class = SQL::Attribute
+        config.inferrer = ROM::SQL::Schema::Inferrer.new.freeze
+        config.plugins << :indexes
+        config.dsl_class = SQL::Schema::DSL
       end
 
-      # @api private
-      def self.define_default_views!
-        undef_method :by_pk if method_defined?(:by_pk)
+      dataset(abstract: true) do |schema|
+        table = opts[:from].first
 
-        if schema.primary_key.size > 1
-          # @!method by_pk(val1, val2)
-          #   Return a relation restricted by its composite primary key
-          #
-          #   @param [Array] args A list with composite pk values
-          #
-          #   @return [SQL::Relation]
-          #
-          #   @api public
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def by_pk(#{schema.primary_key.map(&:name).join(', ')})
-              where(#{schema.primary_key.map { |attr| "schema.canonical[:#{attr.name}] => #{attr.name}" }.join(', ')})
-            end
-          RUBY
+        if db.table_exists?(table)
+          select(*schema.qualified_projection)
+            .order(*schema.project(*schema.primary_key_names).qualified)
         else
-          # @!method by_pk(pk)
-          #   Return a relation restricted by its primary key
-          #
-          #   @param [Object] pk The primary key value
-          #
-          #   @return [SQL::Relation]
-          #
-          #   @api public
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def by_pk(pk)
-              if primary_key.nil?
-                raise MissingPrimaryKeyError.new(
-                  "Missing primary key for :\#{schema.name}"
-                )
-              end
-              where(schema.canonical[schema.canonical.primary_key_name].qualified => pk)
-            end
-          RUBY
+          self
         end
       end
 
-      # @api private
-      def self.associations
-        schema.associations
-      end
-
-      # @api private
-      def self.primary_key_columns(db, table)
-        names = db.respond_to?(:primary_key) ? Array(db.primary_key(table)) : [:id]
-        names.map { |col| :"#{table}__#{col}" }
-      end
-
       option :primary_key, default: -> { schema.primary_key_name }
 
       # Return relation that will load associated tuples of this relation
@@ -121,26 +71,44 @@ module ROM
       # Open a database transaction
       #
       # @param [Hash] opts
-      # @option opts [Boolean] :auto_savepoint Automatically use a savepoint for Database#transaction calls inside this transaction block.
-      # @option opts [Symbol] :isolation The transaction isolation level to use for this transaction, should be :uncommitted, :committed, :repeatable, or :serializable, used if given and the database/adapter supports customizable transaction isolation levels.
-      # @option opts [Integer] :num_retries The number of times to retry if the :retry_on option is used. The default is 5 times. Can be set to nil to retry indefinitely, but that is not recommended.
-      # @option opts [Proc] :before_retry Proc to execute before rertrying if the :retry_on option is used. Called with two arguments: the number of retry attempts (counting the current one) and the error the last attempt failed with.
-      # @option opts [String] :prepare A string to use as the transaction identifier for a prepared transaction (two-phase commit), if the database/adapter supports prepared transactions.
-      # @option opts [Class] :retry_on An exception class or array of exception classes for which to automatically retry the transaction. Can only be set if not inside an existing transaction. Note that this should not be used unless the entire transaction block is idempotent, as otherwise it can cause non-idempotent behavior to execute multiple times.
-      # @option opts [Symbol] :rollback Can the set to :reraise to reraise any Sequel::Rollback exceptions raised, or :always to always rollback even if no exceptions occur (useful for testing).
-      # @option opts [Symbol] :server The server to use for the transaction. Set to :default, :read_only, or whatever symbol you used in the connect string when naming your servers.
-      # @option opts [Boolean] :savepoint Whether to create a new savepoint for this transaction, only respected if the database/adapter supports savepoints. By default Sequel will reuse an existing transaction, so if you want to use a savepoint you must use this option. If the surrounding transaction uses :auto_savepoint, you can set this to false to not use a savepoint. If the value given for this option is :only, it will only create a savepoint if it is inside a transacation.
-      # @option opts [Boolean] :deferrable **PG 9.1+ only** If present, set to DEFERRABLE if true or NOT DEFERRABLE if false.
+      # @option opts [Boolean] :auto_savepoint Automatically use a savepoint for Database#transaction calls inside
+      #   this transaction block.
+      # @option opts [Symbol] :isolation The transaction isolation level to use for this transaction, should be
+      #   :uncommitted, :committed, :repeatable, or :serializable, used if given and the database/adapter supports
+      #   customizable transaction isolation levels.
+      # @option opts [Integer] :num_retries The number of times to retry if the :retry_on option is used. The default is
+      #   5 times. Can be set to nil to retry indefinitely, but that is not recommended.
+      # @option opts [Proc] :before_retry Proc to execute before rertrying if the :retry_on option is used. Called with
+      #   two arguments: the number of retry attempts (counting the current one) and the error the last attempt failed
+      #   with.
+      # @option opts [String] :prepare A string to use as the transaction identifier for a prepared transaction
+      #   (two-phase commit), if the database/adapter supports prepared transactions.
+      # @option opts [Class] :retry_on An exception class or array of exception classes for which to automatically retry
+      #   the transaction. Can only be set if not inside an existing transaction. Note that this should not be used
+      #   unless the entire transaction block is idempotent, as otherwise it can cause non-idempotent behavior to
+      #   execute multiple times.
+      # @option opts [Symbol] :rollback Can the set to :reraise to reraise any Sequel::Rollback exceptions raised, or
+      #   :always to always rollback even if no exceptions occur (useful for testing).
+      # @option opts [Symbol] :server The server to use for the transaction. Set to :default, :read_only, or whatever
+      #   symbol you used in the connect string when naming your servers.
+      # @option opts [Boolean] :savepoint Whether to create a new savepoint for this transaction, only respected if the
+      #   database/adapter supports savepoints. By default Sequel will reuse an existing transaction, so if you want to
+      #   use a savepoint you must use this option. If the surrounding transaction uses :auto_savepoint, you can set
+      #   this to false to not use a savepoint. If the value given for this option is :only, it will only create
+      #   a savepoint if it is inside a transacation.
+      # @option opts [Boolean] :deferrable **PG 9.1+ only** If present, set to DEFERRABLE if true or NOT DEFERRABLE if
+      #   false.
       # @option opts [Boolean] :read_only **PG only** If present, set to READ ONLY if true or READ WRITE if false.
-      # @option opts [Symbol] :synchronous **PG only** if non-nil, set synchronous_commit appropriately. Valid values true, :on, false, :off, :local (9.1+), and :remote_write (9.2+).
+      # @option opts [Symbol] :synchronous **PG only** if non-nil, set synchronous_commit appropriately. Valid values
+      #   true, :on, false, :off, :local (9.1+), and :remote_write (9.2+).
       #
       # @yield [t] Transaction
       #
       # @return [Mixed]
       #
       # @api public
-      def transaction(opts = EMPTY_HASH, &block)
-        Transaction.new(dataset.db).run(opts, &block)
+      def transaction(**opts, &block)
+        Transaction.new(dataset.db).run(**opts, &block)
       end
 
       # Return raw column names

data/lib/rom/sql/restriction_dsl.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rom/sql/dsl'
+require "rom/sql/dsl"
 
 module ROM
   module SQL
@@ -27,7 +27,7 @@ module ROM
           type = type(meth)
 
           if type
-            ::ROM::SQL::Function.new(type).meta(schema: schema)
+            ::ROM::SQL::Function.new(type)
           else
             ::Sequel::VIRTUAL_ROW.__send__(meth, *args, &block)
           end

data/lib/rom/sql/schema/attributes_inferrer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/core/class_attributes'
+require "dry/core/class_attributes"
 
 module ROM
   module SQL
@@ -12,7 +12,7 @@ module ROM
 
         defines :type_builders
 
-        CONSTRAINT_DB_TYPE = 'add_constraint'.freeze
+        CONSTRAINT_DB_TYPE = "add_constraint"
 
         option :type_builder
 
@@ -30,7 +30,7 @@ module ROM
             attr_class.new(type.meta(source: schema.name), name: name) if type
           end.compact
 
-          missing = columns.map(&:first) - inferred.map { |attr| attr.name }
+          missing = columns.map(&:first) - inferred.map(&:name)
 
           [inferred, missing]
         end

data/lib/rom/sql/schema/dsl.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'rom/sql/schema/index_dsl'
+require "rom/compat/schema/dsl"
+require_relative "index_dsl"
 
 module ROM
   module SQL
@@ -8,6 +9,7 @@ module ROM
       # Specialized schema DSL with SQL-specific features
       #
       # @api public
+      # @deprecated
       class DSL < ROM::Schema::DSL
         # @!attribute [r] index_dsl
         #   @return [IndexDSL] Index DSL instance (created only if indexes block is called)
@@ -29,7 +31,7 @@ module ROM
           if index_dsl
             opts = super
 
-            { **opts, indexes: index_dsl.(relation, opts[:attributes]) }
+            {**opts, indexes: index_dsl.(relation, opts[:attributes])}
           else
             super
           end

data/lib/rom/sql/schema/index_dsl.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
 module ROM
   module SQL
     class Schema < ROM::Schema
       # @api public
-      class IndexDSL # < BasicObject
+      class IndexDSL
         extend Initializer
 
         option :attr_class
@@ -16,10 +16,8 @@ module ROM
         # @api private
         def initialize(*, &block)
           super
-
           @registry = []
-
-          instance_exec(&block)
+          instance_exec(&block) if block
         end
         ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
 

data/lib/rom/sql/schema/inferrer.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
-require 'rom/sql/schema/type_builder'
-require 'rom/sql/schema/attributes_inferrer'
-require 'rom/sql/attribute'
+require "rom/sql/schema/type_builder"
+require "rom/sql/schema/attributes_inferrer"
+require "rom/sql/attribute"
 
 module ROM
   module SQL
@@ -38,9 +38,9 @@ module ROM
           else
             infer_from_attributes(gateway, schema, **super)
           end
-        rescue Sequel::Error => error
-          on_error(schema.name, error)
-          { **FALLBACK_SCHEMA, indexes: schema.indexes }
+        rescue Sequel::Error => e
+          on_error(schema.name, e)
+          {**FALLBACK_SCHEMA, indexes: schema.indexes}
         end
 
         # @api private
@@ -49,10 +49,12 @@ module ROM
           indexes = indexes_from_database(gateway, schema, idx)
           foreign_keys = foreign_keys_from_database(gateway, schema, idx)
 
-          { **rest,
-            attributes: attributes.map { |attr| mark_fk(mark_indexed(attr, indexes), foreign_keys) },
+          {**rest,
+            attributes: attributes.map { |attr|
+                          mark_fk(mark_indexed(attr, indexes), foreign_keys)
+                        },
             foreign_keys: foreign_keys,
-            indexes: indexes }
+            indexes: indexes}
         end
 
         # @api private
@@ -60,10 +62,10 @@ module ROM
           indexes = schema.indexes | indexes_from_attributes(attributes)
           foreign_keys = foreign_keys_from_attributes(attributes)
 
-          { **rest,
+          {**rest,
             attributes: attributes.map { |attr| mark_indexed(attr, indexes) },
             foreign_keys: foreign_keys,
-            indexes: indexes }
+            indexes: indexes}
         end
 
         # @api private
@@ -96,18 +98,18 @@ module ROM
 
         # @api private
         def indexes_from_attributes(attributes)
-          attributes.
-            select(&:indexed?).
-            map { |attr| SQL::Index.new([attr.unwrap]) }.
-            to_set
+          attributes
+            .select(&:indexed?)
+            .map { |attr| SQL::Index.new([attr.unwrap]) }
+            .to_set
         end
 
         # @api private
         def foreign_keys_from_attributes(attributes)
-          attributes.
-            select(&:foreign_key?).
-            map { |attr| SQL::ForeignKey.new([attr.unwrap], attr.target) }.
-            to_set
+          attributes
+            .select(&:foreign_key?)
+            .map { |attr| SQL::ForeignKey.new([attr.unwrap], attr.target) }
+            .to_set
         end
 
         # @api private
@@ -151,9 +153,9 @@ module ROM
             raise e
           elsif !silent
             warn "[#{dataset}] failed to infer schema. " \
-                 'Make sure tables exist before ROM container is set up. ' \
-                 'This may also happen when your migration tasks load ROM container, ' \
-                 'which is not needed for migrations as only the connection is required ' \
+                 "Make sure tables exist before ROM container is set up. " \
+                 "This may also happen when your migration tasks load ROM container, " \
+                 "which is not needed for migrations as only the connection is required " \
                  "(#{e.message})"
           end
         end

data/lib/rom/sql/schema/type_builder.rb

@@ -66,9 +66,9 @@ module ROM
         def map_type(ruby_type, db_type, **kw)
           type = self.class.ruby_type_mapping[ruby_type]
 
-          if db_type.is_a?(String) && db_type.include?('numeric') || db_type.include?('decimal')
+          if (db_type.is_a?(String) && db_type.include?("numeric")) || db_type.include?("decimal")
             map_decimal_type(db_type)
-          elsif db_type.is_a?(String) && db_type.include?('char') && kw[:max_length]
+          elsif db_type.is_a?(String) && db_type.include?("char") && kw[:max_length]
             type.meta(limit: kw[:max_length])
           else
             type