rom-sql 1.3.5 → 2.0.0.beta1

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

@@ -1,170 +1,69 @@
 require 'set'
-require 'dry/core/class_attributes'
+
+require 'rom/sql/schema/attributes_inferrer'
+require 'rom/sql/attribute'
 
 module ROM
   module SQL
     class Schema < ROM::Schema
       # @api private
-      class Inferrer
-        extend Dry::Core::ClassAttributes
-
-        defines :ruby_type_mapping, :numeric_pk_type, :db_type, :db_registry
-
-        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
-
-        db_registry Hash.new(self)
-
-        CONSTRAINT_DB_TYPE = 'add_constraint'.freeze
-        DECIMAL_REGEX = /(?:decimal|numeric)\((\d+)(?:,\s*(\d+))?\)/.freeze
-
-        def self.inherited(klass)
-          super
-
-          Inferrer.db_registry[klass.db_type] = klass unless klass.name.nil?
+      class Inferrer < ROM::Schema::Inferrer
+        attributes_inferrer -> (schema, gateway, options) do
+          AttributesInferrer.get(gateway.database_type).with(options).(schema, gateway)
         end
 
-        def self.[](type)
-          Class.new(self) { db_type(type) }
-        end
+        attr_class SQL::Attribute
 
-        def self.get(type)
-          db_registry[type]
-        end
+        option :silent, default: -> { false }
 
-        def self.on_error(relation, e)
-          warn "[#{relation}] 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 " \
-               "(#{e.message})"
-        end
+        option :raise_on_error, default: -> { true }
 
-        # @api private
-        def call(source, gateway)
-          dataset = source.dataset
-
-          columns = filter_columns(gateway.connection.schema(dataset))
-          all_indexes = indexes_for(gateway, dataset)
-          fks = fks_for(gateway, dataset)
-
-          inferred = columns.map do |(name, definition)|
-            indexes = column_indexes(all_indexes, name)
-            type = build_type(**definition, foreign_key: fks[name], indexes: indexes)
-
-            if type
-              type.meta(name: name, source: source)
-            end
-          end.compact
-
-          [inferred, columns.map(&:first) - inferred.map { |attr| attr.meta[:name] }]
-        end
-
-        private
-
-        def filter_columns(schema)
-          schema.reject { |(_, definition)| definition[:db_type] == CONSTRAINT_DB_TYPE }
-        end
-
-        def build_type(primary_key:, db_type:, type:, allow_null:, foreign_key:, indexes:, **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
-              mapped_type = mapped_type.meta(index: indexes) unless indexes.empty?
-
-              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
-
-        def map_pk_type(_ruby_type, _db_type)
-          self.class.numeric_pk_type.meta(primary_key: true)
-        end
-
-        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
+        FALLBACK_SCHEMA = { attributes: EMPTY_ARRAY, indexes: EMPTY_SET }.freeze
 
         # @api private
-        def fks_for(gateway, dataset)
-          gateway.connection.foreign_key_list(dataset).each_with_object({}) do |definition, fks|
-            column, fk = build_fk(definition)
+        def call(schema, gateway)
+          inferred = super
 
-            fks[column] = fk if fk
-          end
+          indexes = get_indexes(gateway, schema.name.dataset, inferred[:attributes])
+
+          { **inferred, indexes: indexes }
+        rescue Sequel::Error => error
+          on_error(schema.name, error)
+          FALLBACK_SCHEMA
         end
 
         # @api private
-        def indexes_for(gateway, dataset)
-          if gateway.connection.respond_to?(:indexes)
-            gateway.connection.indexes(dataset)
+        def get_indexes(gateway, dataset, attributes)
+          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 }
+              }
+
+              SQL::Index.new(columns, name: name)
+            }.to_set
           else
-            # index listing is not implemented
-            EMPTY_HASH
+            attributes.select(&:indexed?).map { |attr| SQL::Index.new([attr]) }.to_set
           end
         end
 
         # @api private
-        def column_indexes(indexes, column)
-          indexes.each_with_object(Set.new) do |(name, idx), indexes|
-            indexes << name if idx[:columns][0] == column
-          end
+        def suppress_errors
+          with(raise_on_error: false, silent: true)
         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
+        private
 
         # @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]
+        def on_error(dataset, e)
+          if raise_on_error
+            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 " \
+                 "(#{e.message})"
           end
         end
       end

data/lib/rom/sql/type_extensions.rb

@@ -0,0 +1,44 @@
+module ROM
+  module SQL
+    # Type-specific methods
+    #
+    # @api public
+    module TypeExtensions
+      class << self
+        # Gets extensions for a type
+        #
+        # @param [Dry::Types::Type] type
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def [](type)
+          unwrapped = type.optional? ? type.right : type
+          @types[unwrapped.pristine] || EMPTY_HASH
+        end
+
+        # Registers a set of operations supported for a specific type
+        #
+        # @example
+        #   ROM::SQL::Attribute::TypeExtensions.register(ROM::SQL::Types::PG::JSONB) do
+        #     def contain(type, expr, keys)
+        #       Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contains(value))
+        #     end
+        #   end
+        #
+        # @param [Dry::Types::Type] type Type
+        #
+        # @api public
+        def register(type, &block)
+          raise ArgumentError, "Type #{ type } already registered" if @types.key?(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) }
+          @types[type] = functions
+        end
+      end
+
+      @types = {}
+    end
+  end
+end

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.3.5'.freeze
+    VERSION = '2.0.0.beta1'.freeze
   end
 end

data/lib/rom/sql/wrap.rb

@@ -0,0 +1,25 @@
+require 'rom/relation/wrap'
+
+module ROM
+  module SQL
+    class Wrap < Relation::Wrap
+      # @api public
+      def schema
+        root.schema.merge(nodes.map(&:schema).reduce(:merge)).qualified
+      end
+
+      # @api private
+      def relation
+        relation = nodes.reduce(root) do |a, e|
+          if associations.key?(e.name.key)
+            a.associations[e.name.key].join(:join, a, e)
+          else
+            # TODO: deprecate this before 2.0
+            a.qualified.join(e.name.dataset, e.meta[:keys])
+          end
+        end
+        schema.(relation)
+      end
+    end
+  end
+end

data/rom-sql.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'sequel', '~> 4.43'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-types', '~> 0.11.0'
+  spec.add_runtime_dependency 'dry-types', '~> 0.11'
   spec.add_runtime_dependency 'dry-core', '~> 0.3'
-  spec.add_runtime_dependency 'rom', '~> 3.2', '>= 3.2.2'
+  spec.add_runtime_dependency 'rom-core', '~> 4.0.0.beta'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/spec/integration/{association → associations}/many_to_many/custom_fks_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
+RSpec.describe ROM::SQL::Associations::ManyToMany, '#call' do
   include_context 'users'
 
   before do
@@ -25,6 +25,8 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
         primary_key [:solver_id, :puzzle_id]
       end
 
+      conf.relation(:puzzles) { schema(infer: true) }
+
       conf.relation(:puzzle_solvers) do
         schema(infer: true) do
           associations do
@@ -55,7 +57,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     end
 
     it 'prepares joined relations using custom FK' do
-      relation = assoc.call(relations).order(puzzles[:text].qualified, puzzle_solvers[:solver_id].qualified)
+      relation = assoc.().order(puzzles[:text].qualified, puzzle_solvers[:solver_id].qualified)
 
       expect(relation.schema.map(&:to_sql_name)).
         to eql([Sequel.qualify(:puzzles, :id),

data/spec/integration/{association → associations}/many_to_many/from_view_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
+RSpec.describe ROM::SQL::Associations::ManyToMany, '#call' do
   include_context 'users'
 
   before do
@@ -70,7 +70,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
     end
 
     it 'prepares joined relations using custom FK' do
-      relation = assoc.call(relations).order(puzzles[:text].qualified, puzzle_solvers[:user_id].qualified)
+      relation = assoc.().order(puzzles[:text].qualified, puzzle_solvers[:user_id].qualified)
 
       expect(relation.schema.map(&:to_sql_name)).
         to eql([Sequel.qualify(:puzzles, :id),

data/spec/integration/{association → associations}/many_to_many_spec.rb

@@ -1,50 +1,45 @@
-RSpec.describe ROM::SQL::Association::ManyToMany do
+RSpec.describe ROM::SQL::Associations::ManyToMany, helpers: true do
   include_context 'users and tasks'
 
   with_adapters do
     context 'through a relation with a composite PK' do
-      subject(:assoc) {
-        ROM::SQL::Association::ManyToMany.new(:tasks, :tags, through: :task_tags)
-      }
+      subject(:assoc) do
+        build_assoc(:many_to_many, :tasks, :tags, through: :task_tags)
+      end
 
-      let(:tags) { container.relations[:tags] }
+      let(:tags) { relations[:tags] }
 
       before do
         conf.relation(:task_tags) do
-          schema do
-            attribute :task_id, ROM::SQL::Types::ForeignKey(:tasks)
-            attribute :tag_id, ROM::SQL::Types::ForeignKey(:tags)
-
-            primary_key :task_id, :tag_id
-
+          schema(infer: true) do
             associations do
-              many_to_one :tasks
-              many_to_one :tags
+              belongs_to :task
+              belongs_to :tag
             end
           end
         end
 
         conf.relation(:tasks) do
-          schema do
-            attribute :id, ROM::SQL::Types::Serial
-            attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
-            attribute :title, ROM::SQL::Types::String
-
+          schema(infer: true) do
             associations do
-              one_to_many :task_tags
-              one_to_many :tags, through: :task_tags
+              has_many :task_tags
+              has_many :tags, through: :task_tags
             end
           end
         end
       end
 
       describe '#result' do
-        specify { expect(ROM::SQL::Association::ManyToMany.result).to be(:many) }
+        specify { expect(assoc.result).to be(:many) }
+      end
+
+      describe '#combine_keys' do
+        specify { expect(assoc.combine_keys).to eql(id: :task_id) }
       end
 
       describe '#call' do
         it 'prepares joined relations' do
-          relation = assoc.call(container.relations)
+          relation = assoc.()
 
           expect(relation.schema.map(&:to_sql_name)).
             to eql([Sequel.qualify(:tags, :id),
@@ -56,11 +51,11 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
 
       describe ':through another assoc' do
         subject(:assoc) do
-          ROM::SQL::Association::ManyToMany.new(:users, :tags, through: :tasks)
+          build_assoc(:many_to_many, :users, :tags, through: :tasks)
         end
 
         it 'prepares joined relations through other association' do
-          relation = assoc.call(container.relations)
+          relation = assoc.()
 
           expect(relation.schema.map(&:to_sql_name)).
             to eql([Sequel.qualify(:tags, :id),
@@ -70,9 +65,9 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         end
       end
 
-      describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+      describe '#eager_load' do
         it 'preloads relation based on association' do
-          relation = tags.for_combine(assoc).call(tasks.call)
+          relation = tags.eager_load(assoc).call(tasks.call)
 
           expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
         end
@@ -80,7 +75,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         it 'maintains original relation' do
           relation = tags.
                        select_append(tags[:name].as(:tag)).
-                       for_combine(assoc).call(tasks.call)
+                       eager_load(assoc).call(tasks.call)
 
           expect(relation.to_a).to eql([id: 1, tag: 'important', name: 'important', task_id: 1])
         end
@@ -91,7 +86,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
 
           relation = tags.
                        order(tags[:name].qualified).
-                       for_combine(assoc).call(tasks.call)
+                       eager_load(assoc).call(tasks.call)
 
           expect(relation.to_a).
             to eql([
@@ -148,7 +143,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         tasks = container.relations[:tasks]
         assoc = users.associations[:tasks]
 
-        relation = tasks.for_combine(assoc).call(users.call)
+        relation = tasks.eager_load(assoc).call(users.call)
 
         expect(relation.to_a).to be_empty
       end
@@ -158,7 +153,7 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         tasks = container.relations[:tasks]
         assoc = users.associations[:priv_tasks]
 
-        relation = tasks.for_combine(assoc).call(users.where(id: 2).call)
+        relation = tasks.eager_load(assoc).call(users.where(id: 2).call)
 
         expect(relation.to_a).to eql([id: 1, user_id: 2, title: "Joe's task"])
       end