rom-sql 3.7.0 → 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
@@ -9,22 +9,20 @@ module ROM
       # Query API for SQL::Relation
       #
       # @api public
-      #
-      # rubocop:disable Metrics/ModuleLength
       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',
-            no_key_update: 'FOR NO KEY UPDATE',
-            share: 'FOR SHARE',
-            key_share: 'FOR KEY SHARE'
+            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',
-            share: 'LOCK IN SHARE MODE'
+            update: "FOR UPDATE",
+            share: "LOCK IN SHARE MODE"
           }
         ).freeze
 
@@ -142,11 +140,11 @@ module ROM
         #                     from tuples
         #
         # @api public
-        def map(key = nil, &)
+        def map(key = nil, &block)
           if key
-            dataset.map(key, &)
+            dataset.map(key, &block)
           else
-            dataset.map(&)
+            dataset.map(&block)
           end
         end
 
@@ -273,8 +271,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def distinct(...)
-          new(dataset.__send__(__method__, ...))
+        def distinct(*args, &block)
+          new(dataset.__send__(__method__, *args, &block))
         end
 
         # Returns a result of SQL SUM clause.
@@ -361,9 +359,9 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def where(*args, &)
-          if block_given?
-            where(*args).where(schema.canonical.restriction(&))
+        def where(*args, &block)
+          if block
+            where(*args).where(schema.canonical.restriction(&block))
           elsif args.size == 1 && args[0].is_a?(Hash)
             new(dataset.where(coerce_conditions(args[0])))
           elsif !args.empty?
@@ -383,8 +381,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def exclude(...)
-          new(dataset.__send__(__method__, ...))
+        def exclude(*args, &block)
+          new(dataset.__send__(__method__, *args, &block))
         end
 
         # Restrict a relation to match grouping criteria
@@ -420,9 +418,9 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def having(*args, &)
-          if block_given?
-            new(dataset.having(*args, *schema.canonical.restriction(&)))
+        def having(*args, &block)
+          if block
+            new(dataset.having(*args, *schema.canonical.restriction(&block)))
           else
             new(dataset.__send__(__method__, *args))
           end
@@ -475,11 +473,11 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def order(*args, &)
-          if block_given?
-            new(dataset.order(*args, *schema.canonical.order(&)))
+        def order(*args, &block)
+          if block
+            new(dataset.order(*args, *schema.canonical.order(&block)))
           else
-            new(dataset.__send__(__method__, *args, &))
+            new(dataset.__send__(__method__, *args, &block))
           end
         end
 
@@ -503,8 +501,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def reverse(...)
-          new(dataset.__send__(__method__, ...))
+        def reverse(*args, &block)
+          new(dataset.__send__(__method__, *args, &block))
         end
 
         # Limit a relation to a specific number of tuples
@@ -592,8 +590,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def join(...)
-          __join__(__method__, ...)
+        def join(*args, &block)
+          __join__(__method__, *args, &block)
         end
         alias_method :inner_join, :join
 
@@ -642,8 +640,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def left_join(...)
-          __join__(__method__, ...)
+        def left_join(*args, &block)
+          __join__(__method__, *args, &block)
         end
 
         # Join with another relation using RIGHT JOIN
@@ -691,8 +689,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def right_join(...)
-          __join__(__method__, ...)
+        def right_join(*args, &block)
+          __join__(__method__, *args, &block)
         end
 
         # Group by specific columns
@@ -724,12 +722,12 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def group(*args, &)
-          if block_given?
+        def group(*args, &block)
+          if block
             if args.size.positive?
-              group(*args).group_append(&)
+              group(*args).group_append(&block)
             else
-              new(dataset.__send__(__method__, *schema.canonical.group(&)))
+              new(dataset.__send__(__method__, *schema.canonical.group(&block)))
             end
           else
             new(dataset.__send__(__method__, *schema.canonical.project(*args)))
@@ -763,12 +761,12 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def group_append(*args, &)
-          if block_given?
+        def group_append(*args, &block)
+          if block
             if args.size.positive?
-              group_append(*args).group_append(&)
+              group_append(*args).group_append(&block)
             else
-              new(dataset.group_append(*schema.canonical.group(&)))
+              new(dataset.group_append(*schema.canonical.group(&block)))
             end
           else
             new(dataset.group_append(*args))
@@ -786,8 +784,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def group_and_count(...)
-          new(dataset.__send__(__method__, ...))
+        def group_and_count(*args, &block)
+          new(dataset.__send__(__method__, *args, &block))
         end
 
         # Select and group by specific columns
@@ -801,8 +799,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def select_group(...)
-          new_schema = schema.project(...)
+        def select_group(*args, &block)
+          new_schema = schema.project(*args, &block)
           new_schema.(self).group(*new_schema)
         end
 
@@ -815,27 +813,26 @@ module ROM
         # @param [Relation] relation Another relation
         #
         # @param [Hash] options Options for union
-        # @option options [Symbol] :alias
-        #         Use the given value as the #from_self alias
-        # @option options [true, false] :all
-        #         Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
-        # @option options [true, false] :from_self
-        #         Set to false to not wrap the returned dataset in a #from_self, use with care.
+        # @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.
         #
         # @returRelation]
         #
         # @api public
-        def union(relation, options = EMPTY_HASH, &)
+        def union(relation, options = EMPTY_HASH, &block)
           # We use the original relation name here if both relations have the
           # same name. This makes it so if the user at some point references
           # the relation directly by name later on things won't break in
           # 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, &)))
+          new_schema.(new(dataset.__send__(__method__, relation.dataset, opts, &block)))
         end
 
         # Checks whether a relation has at least one tuple
@@ -910,12 +907,12 @@ module ROM
         #   @yieldparam relation [Array]
         #
         # @api public
-        def lock(**options, &)
+        def lock(**options, &block)
           clause = lock_clause(**options)
 
-          if block_given?
+          if block
             transaction do
-              yield(dataset.lock_style(clause).to_a)
+              block.call(dataset.lock_style(clause).to_a)
             end
           else
             new(dataset.lock_style(clause))
@@ -963,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)
@@ -1052,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' unless 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
@@ -1073,8 +1070,6 @@ module ROM
         # Apply input types to condition values
         #
         # @api private
-        #
-        # rubocop:disable Metrics/AbcSize
         def coerce_conditions(conditions)
           conditions.each_with_object({}) { |(k, v), h|
             if k.is_a?(Symbol) && schema.canonical.key?(k)
@@ -1087,31 +1082,31 @@ module ROM
             end
           }
         end
-        # rubocop:enable Metrics/AbcSize
 
         # Common join method used by other join methods
         #
         # @api private
         #
-        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity
-        def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &)
+        # 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_given?
+            if join_cond.equal?(EMPTY_HASH) && !block
               assoc = associations[other]
               assoc.join(type, self)
-            elsif block_given?
-              __join__(type, other, JoinDSL.new(schema).(&), opts)
+            elsif block
+              __join__(type, other, JoinDSL.new(schema).(&block), opts)
             else
-              new(dataset.__send__(type, other.to_sym, join_cond, opts, &))
+              new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
             end
-          elsif other.is_a?(::Sequel::SQL::AliasedExpression)
-            new(dataset.__send__(type, other, join_cond, opts, &))
+          elsif other.is_a?(Sequel::SQL::AliasedExpression)
+            new(dataset.__send__(type, other, join_cond, opts, &block))
           elsif other.respond_to?(:name) && other.name.is_a?(Relation::Name)
-            if block_given?
-              join_cond = JoinDSL.new(schema).(&)
+            if block
+              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
@@ -1121,12 +1116,12 @@ module ROM
               associations[other.name.key].join(type, self, other)
             end
           else
-            raise ArgumentError,
-                  "+other+ must be either a symbol or a relation, #{other.class} given"
+            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
-      # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/ModuleLength
     end
   end
 end

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

@@ -16,7 +16,7 @@ module ROM
         # @return [Integer] Number of affected rows
         #
         # @api public
-        def upsert(*args, &)
+        def upsert(*args, &block)
           if args.size > 1 && args[-1].is_a?(Hash)
             *values, opts = args
           else
@@ -24,7 +24,7 @@ module ROM
             opts = EMPTY_HASH
           end
 
-          dataset.insert_conflict(opts).insert(*values, &)
+          dataset.insert_conflict(opts).insert(*values, &block)
         end
 
         # Insert tuple into relation
@@ -119,13 +119,8 @@ module ROM
             dataset.import(columns, other.dataset, options)
           else
             keys = columns.map(&:to_sym)
-            dataset.import(
-              columns,
-              other.to_a.map { |record|
-                record.to_h.values_at(*keys)
-              },
-              options
-            )
+
+            dataset.import(columns, other.to_a.map { |record| record.to_h.values_at(*keys) }, options)
           end
         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,99 +18,36 @@ 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]
-
-        relation.dataset do
-          table = opts[:from].first
+      config.wrap_class = SQL::Wrap
 
-          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
-      #
-      # rubocop:disable Metrics/MethodLength
-      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
-          pks = schema.primary_key
-          # @!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(#{pks.map(&:name).join(", ")})                     # def by_pk(val1, val2)
-              s = schema.canonical                                       #   s = schema.canonical
-              where(                                                     #   where(
-                #{pks.map { "s[:#{_1.name}] => #{_1.name}" }.join(", ")} #     s[:val1] => val1, s[:val2] => val2
-              )                                                          #   )
-            end                                                          # 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)                                    # def by_pk(pk)
-              s = schema.canonical                           #   s = schema.canonical
-              if primary_key.nil?                            #   if primary_key.nil?
-                raise MissingPrimaryKeyError.new(            #     raise MissingPrimaryKeyError.new(
-                  "Missing primary key for :\#{schema.name}" #       "Missing primary key for :#{schema.name}"
-                )                                            #     )
-              end                                            #   end
-              where(s[s.primary_key_name].qualified => pk)   #   where(s[s.primary_key_name].qualified => pk)
-            end                                              # end
-          RUBY
+          self
         end
       end
-      # rubocop:enable Metrics/MethodLength
-
-      # @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 }
 
@@ -131,62 +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 be 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
-      #         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, and :remote_write.
+      # @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+).
       #
       # @yield [t] Transaction
       #
       # @return [Mixed]
       #
       # @api public
-      def transaction(opts = EMPTY_HASH, &)
-        Transaction.new(dataset.db).run(opts, &)
+      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
@@ -19,21 +19,17 @@ module ROM
 
       private
 
-      def respond_to_missing?(_meth, _include_private = false)
-        true
-      end
-
       # @api private
-      def method_missing(meth, ...)
+      def method_missing(meth, *args, &block)
         if schema.key?(meth)
           schema[meth]
         else
           type = type(meth)
 
           if type
-            ::ROM::SQL::Function.new(type).meta(schema: schema)
+            ::ROM::SQL::Function.new(type)
           else
-            ::Sequel::VIRTUAL_ROW.__send__(meth, ...)
+            ::Sequel::VIRTUAL_ROW.__send__(meth, *args, &block)
           end
         end
       end