rom-sql 3.6.4 → 3.7.0

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

@@ -16,7 +16,7 @@ module ROM
         # @return [Integer] Number of affected rows
         #
         # @api public
-        def upsert(*args, &block)
+        def upsert(*args, &)
           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, &block)
+          dataset.insert_conflict(opts).insert(*values, &)
         end
 
         # Insert tuple into relation
@@ -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,13 +113,19 @@ 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)
+            dataset.import(
+              columns,
+              other.to_a.map { |record|
+                record.to_h.values_at(*keys)
+              },
+              options
+            )
           end
         end
       end

data/lib/rom/sql/relation.rb

@@ -37,7 +37,9 @@ module ROM
           table = opts[:from].first
 
           if db.table_exists?(table)
-            select(*schema.qualified_projection).order(*schema.project(*schema.primary_key_names).qualified)
+            select(*schema.qualified_projection).order(
+              *schema.project(*schema.primary_key_names).qualified
+            )
           else
             self
           end
@@ -49,10 +51,13 @@ module ROM
       end
 
       # @api private
+      #
+      # rubocop:disable Metrics/MethodLength
       def self.define_default_views!
         undef_method :by_pk if method_defined?(:by_pk)
 
         if schema.primary_key.size > 1
+          pks = schema.primary_key
           # @!method by_pk(val1, val2)
           #   Return a relation restricted by its composite primary key
           #
@@ -61,10 +66,13 @@ module ROM
           #   @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
+          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
         else
           # @!method by_pk(pk)
@@ -75,18 +83,20 @@ module ROM
           #   @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
+          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
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       # @api private
       def self.associations
@@ -121,26 +131,62 @@ 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] :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 [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.
       #
       # @yield [t] Transaction
       #
       # @return [Mixed]
       #
       # @api public
-      def transaction(opts = EMPTY_HASH, &block)
-        Transaction.new(dataset.db).run(opts, &block)
+      def transaction(opts = EMPTY_HASH, &)
+        Transaction.new(dataset.db).run(opts, &)
       end
 
       # Return raw column names

data/lib/rom/sql/restriction_dsl.rb

@@ -19,8 +19,12 @@ module ROM
 
       private
 
+      def respond_to_missing?(_meth, _include_private = false)
+        true
+      end
+
       # @api private
-      def method_missing(meth, *args, &block)
+      def method_missing(meth, ...)
         if schema.key?(meth)
           schema[meth]
         else
@@ -29,7 +33,7 @@ module ROM
           if type
             ::ROM::SQL::Function.new(type).meta(schema: schema)
           else
-            ::Sequel::VIRTUAL_ROW.__send__(meth, *args, &block)
+            ::Sequel::VIRTUAL_ROW.__send__(meth, ...)
           end
         end
       end

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

@@ -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

@@ -16,8 +16,8 @@ module ROM
         # Define indexes within a block
         #
         # @api public
-        def indexes(&block)
-          @index_dsl = IndexDSL.new(**options, &block)
+        def indexes(&)
+          @index_dsl = IndexDSL.new(**options, &)
         end
 
         private

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

@@ -6,7 +6,7 @@ module ROM
   module SQL
     class Schema < ROM::Schema
       # @api public
-      class IndexDSL # < BasicObject
+      class IndexDSL
         extend Initializer
 
         option :attr_class
@@ -14,14 +14,13 @@ module ROM
         attr_reader :registry
 
         # @api private
-        def initialize(*, &block)
+        def initialize(*, **, &)
           super
 
           @registry = []
 
-          instance_exec(&block)
+          instance_exec(&)
         end
-        ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
 
         # @api public
         def index(*attributes, **options)
@@ -34,9 +33,9 @@ module ROM
             attr_class.new(attr[:type], **(attr[:options] || {})).meta(source: schema_name)
           end
 
-          registry.map { |attr_names, options|
+          registry.to_set do |attr_names, options|
             build_index(attributes, attr_names, options)
-          }.to_set
+          end
         end
 
         private

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

@@ -38,8 +38,8 @@ module ROM
           else
             infer_from_attributes(gateway, schema, **super)
           end
-        rescue Sequel::Error => error
-          on_error(schema.name, error)
+        rescue Sequel::Error => e
+          on_error(schema.name, e)
           { **FALLBACK_SCHEMA, indexes: schema.indexes }
         end
 
@@ -49,10 +49,14 @@ 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 +64,12 @@ 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
@@ -71,12 +77,12 @@ module ROM
           if gateway.connection.respond_to?(:indexes)
             dataset = schema.name.dataset
 
-            gateway.connection.indexes(dataset).map { |index_name, definition|
+            gateway.connection.indexes(dataset).to_set do |index_name, definition|
               columns, unique = definition.values_at(:columns, :unique)
               attrs = columns.map { |name| attributes[name] }
 
               SQL::Index.new(attrs, name: index_name, unique: unique)
-            }.to_set
+            end
           else
             EMPTY_SET
           end
@@ -86,28 +92,26 @@ module ROM
         def foreign_keys_from_database(gateway, schema, attributes)
           dataset = schema.name.dataset
 
-          gateway.connection.foreign_key_list(dataset).map { |definition|
+          gateway.connection.foreign_key_list(dataset).to_set do |definition|
             columns, table, key = definition.values_at(:columns, :table, :key)
             attrs = columns.map { |name| attributes[name] }
 
             SQL::ForeignKey.new(attrs, table, parent_keys: key)
-          }.to_set
+          end
         end
 
         # @api private
         def indexes_from_attributes(attributes)
-          attributes.
-            select(&:indexed?).
-            map { |attr| SQL::Index.new([attr.unwrap]) }.
-            to_set
+          attributes
+            .select(&:indexed?)
+            .to_set { |attr| SQL::Index.new([attr.unwrap]) }
         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?)
+            .to_set { |attr| SQL::ForeignKey.new([attr.unwrap], attr.target) }
         end
 
         # @api private

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

@@ -21,7 +21,7 @@ module ROM
 
         defines :ruby_type_mapping, :numeric_pk_type
 
-        DECIMAL_REGEX = /(?:decimal|numeric)\((\d+)(?:,\s*(\d+))?\)/.freeze
+        DECIMAL_REGEX = /(?:decimal|numeric)\((\d+)(?:,\s*(\d+))?\)/
 
         ruby_type_mapping(
           integer: Types::Integer,
@@ -37,6 +37,10 @@ module ROM
 
         numeric_pk_type Types::Serial
 
+        TYPE_GUESSES = {
+          /datetime\((\d+)\)/ => :datetime
+        }.freeze
+
         def call(primary_key:, db_type:, type:, allow_null:, **rest)
           if primary_key
             map_pk_type(type, db_type, **rest)
@@ -63,10 +67,12 @@ module ROM
         end
 
         # @api private
+        #
+        # rubocop:disable Metrics/PerceivedComplexity
         def map_type(ruby_type, db_type, **kw)
-          type = self.class.ruby_type_mapping[ruby_type]
+          type = self.class.ruby_type_mapping[ruby_type || guess_type(db_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]
             type.meta(limit: kw[:max_length])
@@ -74,6 +80,16 @@ module ROM
             type
           end
         end
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        # @api private
+        def guess_type(db_type)
+          TYPE_GUESSES.find do |regex, type|
+            if db_type.is_a?(String) && db_type.match(regex)
+              break type
+            end
+          end
+        end
 
         # @api private
         def map_decimal_type(type)

data/lib/rom/sql/schema.rb

@@ -32,8 +32,8 @@ module ROM
       # @return [Mixed] Result of the block call
       #
       # @api public
-      def restriction(&block)
-        RestrictionDSL.new(self).call(&block)
+      def restriction(&)
+        RestrictionDSL.new(self).call(&)
       end
 
       # Open Order DSL for setting ORDER clause in queries
@@ -43,8 +43,8 @@ module ROM
       # @return [Mixed] Result of the block call
       #
       # @api public
-      def order(&block)
-        OrderDSL.new(self).call(&block)
+      def order(&)
+        OrderDSL.new(self).call(&)
       end
 
       # Open Group DSL for setting GROUP BY clause in queries
@@ -54,8 +54,8 @@ module ROM
       # @return [Mixed] Result of the block call
       #
       # @api public
-      def group(&block)
-        GroupDSL.new(self).call(&block)
+      def group(&)
+        GroupDSL.new(self).call(&)
       end
 
       # Return a new schema with attributes marked as qualified
@@ -87,9 +87,9 @@ module ROM
       # @return [Schema] A new schema with projected attributes
       #
       # @api public
-      def project(*names, &block)
-        if block
-          super(*(names + ProjectionDSL.new(self).(&block)))
+      def project(*names, &)
+        if block_given?
+          super(*(names + ProjectionDSL.new(self).(&)))
         else
           super
         end
@@ -141,7 +141,7 @@ module ROM
       #
       # @api public
       def call(relation)
-        relation.new(relation.dataset.select(*self.qualified_projection), schema: self)
+        relation.new(relation.dataset.select(*qualified_projection), schema: self)
       end
 
       # Return an empty schema

data/lib/rom/sql/tasks/migration_tasks.rake

@@ -13,8 +13,8 @@ module ROM
           gateway.run_migrations(migration_options.merge(options))
         end
 
-        def create_migration(*args)
-          gateway.migrator.create_file(*args)
+        def create_migration(...)
+          gateway.migrator.create_file(...)
         end
 
         # Global environment used for running migrations. You normally
@@ -24,8 +24,7 @@ module ROM
         # @api public
         attr_accessor :env
 
-
-        # Migration options, which are passed to `ROM::SQL::RakeSupport.run_migrations`. You can 
+        # Migration options, which are passed to `ROM::SQL::RakeSupport.run_migrations`. You can
         # set them in the `db:setup` task with `ROM::SQL::RakeSupport.migration_options = { ... }`
         #
         # @api public
@@ -84,7 +83,7 @@ namespace :db do
   end
 
   desc 'Create a migration (parameters: NAME, VERSION)'
-  task :create_migration, [:name, :version] => :rom_configuration do |_, args|
+  task :create_migration, %i[name version] => :rom_configuration do |_, args|
     name, version = args.values_at(:name, :version)
 
     if name.nil?

data/lib/rom/sql/transaction.rb

@@ -8,6 +8,7 @@ module ROM
       private :connection
 
       def initialize(connection)
+        super()
         @connection = connection
       end
 

data/lib/rom/sql/type_dsl.rb

@@ -6,7 +6,11 @@ module ROM
     #
     # @api public
     class TypeDSL
-      attr_reader :definition, :input_constructor, :output_constructor
+      attr_reader :definition
+
+      attr_reader :input_constructor
+
+      attr_reader :output_constructor
 
       # @api private
       def initialize(value_type)
@@ -18,8 +22,8 @@ module ROM
       end
 
       # @api private
-      def call(&block)
-        instance_exec(&block)
+      def call(&)
+        instance_exec(&)
 
         definition.constructor(input_constructor)
           .meta(read: definition.constructor(output_constructor))

data/lib/rom/sql/type_extensions.rb

@@ -30,13 +30,13 @@ module ROM
         # @param [Dry::Types::Type] type Type
         #
         # @api public
-        def register(type, &block)
+        def register(type, &)
           extensions = @types[type.meta[:database]]
           db_type = type.meta[:db_type]
 
-          mod = Module.new(&block)
-          ctx = Object.new.extend(mod)
-          functions = mod.public_instance_methods.each_with_object({}) { |m, ms| ms[m] = ctx.method(m) }
+          mod = ::Module.new(&)
+          ctx = ::Object.new.extend(mod)
+          functions = mod.public_instance_methods.to_h { |m| [m, ctx.method(m)] }
           extensions[db_type] = (extensions[db_type] || {}).merge(functions)
         end
       end

data/lib/rom/sql/type_serializer.rb

@@ -29,7 +29,7 @@ module ROM
         Types::Date => 'date',
         Types::Bool => 'boolean',
         Types::Decimal => 'numeric',
-        Types::Float => 'float',
+        Types::Float => 'float'
       )
 
       def call(type)
@@ -40,7 +40,7 @@ module ROM
         self.class.mapping.fetch(type.with(meta: meta)) {
           if block_given?
             yield(type)
-          end or raise "Cannot serialize #{ type }"
+          end or raise "Cannot serialize #{type}"
         }
       end
     end

data/lib/rom/sql/types.rb

@@ -37,8 +37,8 @@ module ROM
       # @return [Dry::Types::Nominal]
       #
       # @api public
-      def self.define(value_type, &block)
-        TypeDSL.new(value_type).call(&block)
+      def self.define(value_type, &)
+        TypeDSL.new(value_type).call(&)
       end
 
       Serial = Integer.meta(primary_key: true)

data/lib/rom/sql/version.rb

@@ -2,6 +2,6 @@
 
 module ROM
   module SQL
-    VERSION = "3.6.4"
+    VERSION = '3.7.0'
   end
 end

data/lib/rom/types/values.rb

@@ -5,11 +5,9 @@ require 'rom/sql/types'
 module ROM
   module Types
     module Values
-      class TreePath < ::Struct.new(:value, :separator)
-        DEFAULT_SEPARATOR = '.'.freeze
-
+      class TreePath < ::Struct.new(:value, :separator) # rubocop:disable Style/StructInheritance
         # @api public
-        def self.new(value, separator = DEFAULT_SEPARATOR)
+        def self.new(value, separator = '.')
           super
         end