rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/lib/rom/sql/relation.rb

@@ -6,7 +6,6 @@ require 'rom/sql/transaction'
 
 require 'rom/sql/relation/reading'
 require 'rom/sql/relation/writing'
-require 'rom/sql/relation/sequel_api'
 
 module ROM
   module SQL
@@ -49,6 +48,8 @@ module ROM
 
       # @api private
       def self.define_default_views!
+        undef_method :by_pk if method_defined?(:by_pk)
+
         if schema.primary_key.size > 1
           # @!method by_pk(val1, val2)
           #   Return a relation restricted by its composite primary key

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

@@ -105,8 +105,8 @@ module ROM
         # @return [Relation]
         #
         # @api public
-        def qualified
-          schema.qualified.(self)
+        def qualified(table_alias = nil)
+          schema.qualified(table_alias).(self)
         end
 
         # Return a list of qualified column names
@@ -768,7 +768,7 @@ module ROM
         # @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.
         #
-        # @return [Relation]
+        # @returRelation]
         #
         # @api public
         def union(relation, options = EMPTY_HASH, &block)
@@ -859,6 +859,66 @@ module ROM
           end
         end
 
+        # Restrict with rows from another relation.
+        # Accepts only SQL relations and uses the EXISTS
+        # clause under the hood
+        #
+        # @example using associations
+        #   users.exists(tasks)
+        #
+        # @example using provided condition
+        #   users.exists(tasks, tasks[:user_id] => users[:id])
+        #
+        # @param [SQL::Relation] other The other relation
+        # @param [Hash,Object] condition An optional join condition
+        #
+        # @return [SQL::Relation]
+        #
+        # @api public
+        def exists(other, condition = nil)
+          join_condition = condition || associations[other.name].join_keys
+          where(other.where(join_condition).dataset.exists)
+        end
+
+        # Process the dataset in batches.
+        # The method yields a relation restricted by a primary key value.
+        # This means it discards any order internally and uses the PK sort.
+        # Currently, works only with a single-column primary key.
+        #
+        # @example update in batches
+        #   users.each_batch do |rel|
+        #     rel.
+        #       command(:update).
+        #       call(name: users[:first_name].concat(users[:last_name])
+        #   end
+        #
+        # @option [Integer] size The size of a batch (max number of records)
+        # @yieldparam [SQL::Relation]
+        #
+        # @api public
+        def each_batch(size: 1000)
+          pks = schema.primary_key
+
+          if pks.size > 1
+            raise ArgumentError, 'Composite primary keys are not supported yet'
+          end
+
+          source = order(pks[0]).limit(size)
+          rel = source
+
+          loop do
+            ids = rel.pluck(primary_key)
+
+            break if ids.empty?
+
+            yield(rel)
+
+            break if ids.size < size
+
+            rel = source.where(pks[0] > ids.last)
+          end
+        end
+
         private
 
         # Build a locking clause

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

@@ -77,6 +77,44 @@ module ROM
         def delete(*args, &block)
           dataset.delete(*args, &block)
         end
+
+        # Insert tuples from other relation
+        # NOTE: The method implicitly uses a transaction
+        #
+        # @example
+        #   users.import(new_users)
+        #
+        # @overload import(other_sql_relation, options)
+        #   If both relations uses the same gateway
+        #   the INSERT ... SELECT statement will
+        #   be used for importing the data
+        #
+        #   @params [SQL::Relation] other_sql_relation
+        #
+        #   @option [Integer] :slice
+        #     Split loading into batches of provided size,
+        #     every batch will be processed in a separate
+        #     transaction block
+        #
+        # @overload import(other, options)
+        #   Import data from another relation. The source
+        #   relation will be materialized before loading
+        #
+        #   @params [Relation] other
+        #
+        #   @option [Integer] :slice
+        #
+        # @api public
+        def import(other, options = EMPTY_HASH)
+          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
       end
     end
   end

data/lib/rom/sql/schema.rb

@@ -6,15 +6,20 @@ require 'rom/sql/group_dsl'
 require 'rom/sql/projection_dsl'
 require 'rom/sql/restriction_dsl'
 require 'rom/sql/index'
+require 'rom/sql/foreign_key'
 require 'rom/sql/schema/inferrer'
 
 module ROM
   module SQL
     class Schema < ROM::Schema
-      # @!attribute [r] attributes
+      # @!attribute [r] indexes
       #   @return [Array<Index>] Array with schema indexes
       option :indexes, default: -> { EMPTY_SET }
 
+      # @!attribute [r] foreign_keys
+      #   @return [Array<ForeignKey>] Array with foreign keys
+      option :foreign_keys, default: -> { EMPTY_SET }
+
       # @api public
       def restriction(&block)
         RestrictionDSL.new(self).call(&block)
@@ -35,8 +40,8 @@ module ROM
       # @return [Schema]
       #
       # @api public
-      def qualified
-        new(map(&:qualified))
+      def qualified(table_alias = nil)
+        new(map { |attr| attr.qualified(table_alias) })
       end
 
       # Return a new schema with attributes restored to canonical form
@@ -100,6 +105,7 @@ module ROM
       # @api private
       def finalize_attributes!(options = EMPTY_HASH)
         super do
+          @attributes = map(&:qualified)
           initialize_primary_key_names
         end
       end

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

@@ -8,42 +8,11 @@ module ROM
         extend Dry::Core::ClassAttributes
         extend Initializer
 
-        defines :ruby_type_mapping, :numeric_pk_type, :db_type, :registry
-
-        class << self
-          def inherited(klass)
-            super
-
-            registry[klass.db_type] = klass.new.freeze unless klass.name.nil?
-          end
-
-          def [](type)
-            Class.new(self) { db_type(type) }
-          end
-
-          def get(db_type)
-            registry[db_type]
-          end
-        end
+        defines :type_builders
 
         CONSTRAINT_DB_TYPE = 'add_constraint'.freeze
-        DECIMAL_REGEX = /(?:decimal|numeric)\((\d+)(?:,\s*(\d+))?\)/.freeze
 
-        registry Hash.new(new.freeze)
-
-        ruby_type_mapping(
-          integer: Types::Int,
-          string: Types::String,
-          time: Types::Time,
-          date: Types::Date,
-          datetime: Types::Time,
-          boolean: Types::Bool,
-          decimal: Types::Decimal,
-          float: Types::Float,
-          blob: Types::Blob
-        ).freeze
-
-        numeric_pk_type Types::Serial
+        option :type_builder
 
         option :attr_class, optional: true
 
@@ -52,10 +21,9 @@ module ROM
           dataset = schema.name.dataset
 
           columns = filter_columns(gateway.connection.schema(dataset))
-          fks = fks_for(gateway, dataset)
 
           inferred = columns.map do |(name, definition)|
-            type = build_type(**definition, foreign_key: fks[name])
+            type = type_builder.(definition)
 
             attr_class.new(type.meta(name: name, source: schema.name)) if type
           end.compact
@@ -70,94 +38,10 @@ module ROM
           self.class.new(options.merge(new_options))
         end
 
-
         # @api private
         def filter_columns(schema)
           schema.reject { |(_, definition)| definition[:db_type] == CONSTRAINT_DB_TYPE }
         end
-
-        # @api private
-        def build_type(primary_key:, db_type:, type:, allow_null:, foreign_key:, **rest)
-          if primary_key
-            map_pk_type(type, db_type)
-          else
-            mapped_type = map_type(type, db_type, rest)
-
-            if mapped_type
-              read_type = mapped_type.meta[:read]
-              mapped_type = mapped_type.optional if allow_null
-              mapped_type = mapped_type.meta(foreign_key: true, target: foreign_key) if foreign_key
-
-              if read_type && allow_null
-                mapped_type.meta(read: read_type.optional)
-              elsif read_type
-                mapped_type.meta(read: read_type)
-              else
-                mapped_type
-              end
-            end
-          end
-        end
-
-        # @api private
-        def map_pk_type(_ruby_type, _db_type)
-          self.class.numeric_pk_type.meta(primary_key: true)
-        end
-
-        # @api private
-        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')
-            map_decimal_type(db_type)
-          elsif db_type.is_a?(String) && db_type.include?('char') && kw[:max_length]
-            type.meta(limit: kw[:max_length])
-          else
-            type
-          end
-        end
-
-        # @api private
-        def fks_for(gateway, dataset)
-          gateway.connection.foreign_key_list(dataset).each_with_object({}) do |definition, fks|
-            column, fk = build_fk(definition)
-
-            fks[column] = fk if fk
-          end
-        end
-
-        # @api private
-        def column_indexes(indexes, column)
-          indexes.each_with_object(Set.new) do |(name, idx), set|
-            set << name if idx[:columns][0] == column
-          end
-        end
-
-        # @api private
-        def build_fk(columns: , table: , **rest)
-          if columns.size == 1
-            [columns[0], table]
-          else
-            # We don't have support for multicolumn foreign keys
-            columns[0]
-          end
-        end
-
-        # @api private
-        def map_decimal_type(type)
-          precision = DECIMAL_REGEX.match(type)
-
-          if precision
-            prcsn, scale = precision[1..2].map(&:to_i)
-
-            self.class.ruby_type_mapping[:decimal].meta(
-              precision: prcsn,
-              scale: scale
-            )
-          else
-            self.class.ruby_type_mapping[:decimal]
-          end
-        end
       end
     end
   end

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

@@ -1,5 +1,6 @@
 require 'set'
 
+require 'rom/sql/schema/type_builder'
 require 'rom/sql/schema/attributes_inferrer'
 require 'rom/sql/attribute'
 
@@ -8,8 +9,12 @@ module ROM
     class Schema < ROM::Schema
       # @api private
       class Inferrer < ROM::Schema::Inferrer
+        defines :type_builders
+
         attributes_inferrer -> (schema, gateway, options) do
-          AttributesInferrer.get(gateway.database_type).with(options).(schema, gateway)
+          builder = TypeBuilder[gateway.database_type]
+          inferrer = AttributesInferrer.new(type_builder: builder, **options)
+          inferrer.(schema, gateway)
         end
 
         attr_class SQL::Attribute
@@ -18,39 +23,87 @@ module ROM
 
         option :raise_on_error, default: -> { true }
 
-        FALLBACK_SCHEMA = { attributes: EMPTY_ARRAY, indexes: EMPTY_SET }.freeze
+        FALLBACK_SCHEMA = {
+          attributes: EMPTY_ARRAY,
+          indexes: EMPTY_SET,
+          foreign_keys: EMPTY_SET
+        }.freeze
 
         # @api private
         def call(schema, gateway)
-          inferred = super
-
-          indexes = get_indexes(gateway, schema, inferred[:attributes])
-
-          { **inferred, indexes: indexes }
+          if enabled?
+            infer_from_database(gateway, schema, super)
+          else
+            infer_from_attributes(gateway, schema, super)
+          end
         rescue Sequel::Error => error
           on_error(schema.name, error)
-          FALLBACK_SCHEMA
+          { **FALLBACK_SCHEMA, indexes: schema.indexes }
         end
 
         # @api private
-        def get_indexes(gateway, schema, attributes)
-          dataset = schema.name.dataset
+        def infer_from_database(gateway, schema, attributes:, **rest)
+          idx = attributes_index(attributes)
+          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) },
+            foreign_keys: foreign_keys,
+            indexes: indexes }
+        end
 
-          if enabled? && gateway.connection.respond_to?(:indexes)
-            gateway.connection.indexes(dataset).map { |name, body|
-              columns = body[:columns].map { |name|
-                attributes.find { |attr| attr.name == name }.unwrap
-              }
+        # @api private
+        def infer_from_attributes(gateway, schema, attributes:, **rest)
+          indexes = schema.indexes | indexes_from_attributes(attributes)
+          foreign_keys = foreign_keys_from_attributes(attributes)
+
+          { **rest,
+            attributes: attributes.map { |attr| mark_indexed(attr, indexes) },
+            foreign_keys: foreign_keys,
+            indexes: indexes }
+        end
 
-              SQL::Index.new(columns, name: name, unique: body[:unique])
+        # @api private
+        def indexes_from_database(gateway, schema, attributes)
+          if gateway.connection.respond_to?(:indexes)
+            dataset = schema.name.dataset
+
+            gateway.connection.indexes(dataset).map { |index_name, columns:, unique:, **rest|
+              attrs = columns.map { |name| attributes[name] }
+
+              SQL::Index.new(attrs, name: index_name, unique: unique)
             }.to_set
           else
-            schema.indexes | indexes_from_attributes(attributes)
+            EMPTY_SET
           end
         end
 
+        # @api private
+        def foreign_keys_from_database(gateway, schema, attributes)
+          dataset = schema.name.dataset
+
+          gateway.connection.foreign_key_list(dataset).map { |columns:, table:, key:, **rest|
+            attrs = columns.map { |name| attributes[name] }
+
+            SQL::ForeignKey.new(attrs, table, parent_keys: key)
+          }.to_set
+        end
+
+        # @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
         end
 
         # @api private
@@ -60,6 +113,34 @@ module ROM
 
         private
 
+        def attributes_index(attributes)
+          Hash.new { |idx, name| idx[name] = attributes.find { |attr| attr.name == name }.unwrap }
+        end
+
+        # @private
+        def mark_indexed(attribute, indexes)
+          if !attribute.indexed? && indexes.any? { |index| index.can_access?(attribute) }
+            attribute.indexed
+          else
+            attribute
+          end
+        end
+
+        # @private
+        def mark_fk(attribute, foreign_keys)
+          if attribute.foreign_key?
+            attribute
+          else
+            foreign_key = foreign_keys.find { |fk| fk.attributes.map(&:name) == [attribute.name] }
+
+            if foreign_key.nil?
+              attribute
+            else
+              attribute.meta(foreign_key: true, target: foreign_key.parent_table)
+            end
+          end
+        end
+
         # @api private
         def on_error(dataset, e)
           if raise_on_error