rom-sql 1.3.5 → 2.0.0.beta1

data/lib/rom/sql/plugin/associates.rb

@@ -1,3 +1,5 @@
+require 'rom/sql/associations'
+
 module ROM
   module SQL
     module Plugin
@@ -5,42 +7,18 @@ module ROM
       #
       # @api private
       module Associates
-        class MissingJoinKeysError < StandardError
-          ERROR_TEMPLATE = ':%{command} command for :%{relation} relation ' \
-                           'is missing join keys configuration for :%{name} association'
-
-          def initialize(command, assoc_name)
-            super(ERROR_TEMPLATE % tokens(command, assoc_name))
-          end
-
-          def tokens(command, assoc_name)
-            { command: command.register_as,
-              relation: command.relation,
-              name: assoc_name }
-          end
-        end
-
         class AssociateOptions
           attr_reader :name, :assoc, :opts
 
           def initialize(name, relation, opts)
             @name = name
-            @opts = { assoc: name, keys: opts[:key] }
-
-            relation.associations.try(name) do |assoc|
-              @assoc = assoc
-              @opts.update(assoc: assoc, keys: assoc.join_keys(relation.__registry__))
-            end
-
+            @assoc = relation.associations[name]
+            @opts = { assoc: assoc, keys: assoc.join_keys }
             @opts.update(parent: opts[:parent]) if opts[:parent]
           end
 
           def after?
-            assoc.is_a?(Association::ManyToMany)
-          end
-
-          def ensure_valid(command)
-            raise MissingJoinKeysError.new(command, name) unless opts[:keys]
+            assoc.is_a?(SQL::Associations::ManyToMany)
           end
 
           def to_hash
@@ -53,6 +31,7 @@ module ROM
           klass.class_eval do
             extend ClassMethods
             include InstanceMethods
+
             defines :associations
 
             associations Hash.new
@@ -77,8 +56,6 @@ module ROM
               AssociateOptions.new(name, relation, opts)
             }.compact
 
-            associate_options.each { |opts| opts.ensure_valid(self) }
-
             before_hooks = associate_options.reject(&:after?).map(&:to_hash)
             after_hooks = associate_options.select(&:after?).map(&:to_hash)
 
@@ -133,18 +110,12 @@ module ROM
 
             output_tuples =
               case assoc
-              when Symbol
-                fk, pk = keys
-
-                with_input_tuples(tuples).map { |tuple|
-                  tuple.merge(fk => parent.fetch(pk))
-                }
-              when Association::ManyToMany
+              when SQL::Associations::ManyToMany
                 result_type = tuples.is_a?(Array) ? :many : :one
 
-                assoc.persist(__registry__, tuples, parent)
+                assoc.persist(tuples, parent)
 
-                pk, fk = assoc.parent_combine_keys(__registry__)
+                pk, fk = assoc.parent_combine_keys
 
                 case parent
                 when Array
@@ -154,9 +125,9 @@ module ROM
                 else
                   tuples.map { |tuple| Hash(tuple).update(fk => parent[pk]) }
                 end
-              when Association
+              else
                 with_input_tuples(tuples).map { |tuple|
-                  assoc.associate(__registry__, tuple, parent)
+                  assoc.associate(tuple, parent)
                 }
               end
 
@@ -171,11 +142,6 @@ module ROM
               associations: associations.merge(name => opts)
             )
           end
-
-          # @api private
-          def __registry__
-            relation.__registry__
-          end
         end
       end
     end

data/lib/rom/sql/plugin/pagination.rb

@@ -59,9 +59,9 @@ module ROM
         # Paginate a relation
         #
         # @example
-        #   rom.relation(:users).class.per_page(10)
-        #   rom.relation(:users).page(1)
-        #   rom.relation(:users).pager # => info about pagination
+        #   rom.relations[:users].class.per_page(10)
+        #   rom.relations[:users].page(1)
+        #   rom.relations[:users].pager # => info about pagination
         #
         # @return [Relation]
         #
@@ -74,7 +74,7 @@ module ROM
         # Set limit for pagination
         #
         # @example
-        #   rom.relation(:users).page(2).per_page(10)
+        #   rom.relations[:users].page(2).per_page(10)
         #
         # @api public
         def per_page(num)

data/lib/rom/sql/relation.rb

@@ -1,70 +1,50 @@
 require 'rom/sql/types'
 require 'rom/sql/schema'
+require 'rom/sql/attribute'
+require 'rom/sql/wrap'
 
 require 'rom/sql/relation/reading'
 require 'rom/sql/relation/writing'
 require 'rom/sql/relation/sequel_api'
 
-require 'rom/plugins/relation/key_inference'
-require 'rom/plugins/relation/sql/auto_combine'
-require 'rom/plugins/relation/sql/auto_wrap'
-
 module ROM
   module SQL
     # Sequel-specific relation extensions
     #
     # @api public
     class Relation < ROM::Relation
-      include SQL
-
       adapter :sql
 
-      use :key_inference
-      use :auto_combine
-      use :auto_wrap
-
+      include SQL
       include Writing
       include Reading
 
-      schema_dsl SQL::Schema::DSL
-
-      # Set default dataset for a relation sub-class
-      #
-      # @api private
-      def self.inherited(klass)
-        super
+      extend Notifications::Listener
 
-        klass.class_eval do
-          schema_inferrer -> (name, gateway) do
-            inferrer_for_db = ROM::SQL::Schema::Inferrer.get(gateway.connection.database_type.to_sym)
-            begin
-              inferrer_for_db.new.call(name, gateway)
-            rescue Sequel::Error => e
-              inferrer_for_db.on_error(klass, e)
-              ROM::Schema::DEFAULT_INFERRER.()
-            end
-          end
+      schema_class SQL::Schema
+      schema_attr_class SQL::Attribute
+      schema_inferrer ROM::SQL::Schema::Inferrer.new.freeze
+      wrap_class SQL::Wrap
 
-          dataset do
-            # TODO: feels strange to do it here - we need a new hook for this during finalization
-            klass.define_default_views!
-            schema = klass.schema
+      subscribe('configuration.relations.schema.set', adapter: :sql) do |event|
+        schema = event[:schema]
+        relation = event[:relation]
 
-            table = opts[:from].first
+        relation.dataset do
+          table = opts[:from].first
 
-            if db.table_exists?(table)
-              if schema
-                select(*schema.map(&:to_sql_name)).order(*schema.project(*schema.primary_key_names).qualified.map(&:to_sql_name))
-              else
-                select(*columns).order(*klass.primary_key_columns(db, table))
-              end
-            else
-              self
-            end
+          if db.table_exists?(table)
+            select(*schema.map(&:qualified)).order(*schema.project(*schema.primary_key_names).qualified)
+          else
+            self
           end
         end
       end
 
+      subscribe('configuration.relations.dataset.allocated', adapter: :sql) do |event|
+        event[:relation].define_default_views!
+      end
+
       # @api private
       def self.define_default_views!
         if schema.primary_key.size > 1
@@ -130,7 +110,7 @@ module ROM
       #
       # @api public
       def assoc(name)
-        associations[name].(__registry__)
+        associations[name].()
       end
 
       # Return raw column names

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

@@ -902,17 +902,17 @@ module ROM
         #
         # @api private
         def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &block)
-          if other.is_a?(Symbol) || other.is_a?(Association::Name)
+          if other.is_a?(Symbol) || other.is_a?(ROM::Relation::Name)
             if join_cond.empty?
               assoc = associations[other]
-              assoc.join(__registry__, type, self, __registry__[assoc.target.relation])
+              assoc.join(type, self)
             else
               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, &block))
           elsif other.respond_to?(:name) && other.name.is_a?(Relation::Name)
-            associations[other.name.dataset].join(__registry__, type, self, other)
+            associations[other.name.key].join(type, self, other)
           else
             raise ArgumentError, "+other+ must be either a symbol or a relation, #{other.class} given"
           end

data/lib/rom/sql/schema.rb

@@ -1,26 +1,18 @@
 require 'rom/schema'
+
 require 'rom/sql/order_dsl'
 require 'rom/sql/group_dsl'
 require 'rom/sql/projection_dsl'
 require 'rom/sql/restriction_dsl'
+require 'rom/sql/index'
+require 'rom/sql/schema/inferrer'
 
 module ROM
   module SQL
     class Schema < ROM::Schema
-      # @!attribute [r] primary_key_name
-      #   @return [Symbol] The name of the primary key. This is set because in
-      #                    most of the cases relations don't have composite pks
-      attr_reader :primary_key_name
-
-      # @!attribute [r] primary_key_names
-      #   @return [Array<Symbol>] A list of all pk names
-      attr_reader :primary_key_names
-
-      # @api private
-      def initialize(*)
-        super
-        initialize_primary_key_names
-      end
+      # @!attribute [r] attributes
+      #   @return [Array<Index>] Array with schema indexes
+      option :indexes, default: -> { EMPTY_ARRAY }
 
       # @api public
       def restriction(&block)
@@ -105,21 +97,22 @@ module ROM
       end
 
       # @api private
-      def finalize!(*args)
+      def finalize_attributes!(options = EMPTY_HASH)
         super do
           initialize_primary_key_names
         end
       end
 
       # @api private
-      def initialize_primary_key_names
-        if primary_key.size > 0
-          @primary_key_name = primary_key[0].meta[:name]
-          @primary_key_names = primary_key.map { |type| type.meta[:name] }
+      def finalize_associations!(relations:)
+        super do
+          associations.map do |definition|
+            SQL::Associations.const_get(definition.type).new(definition, relations)
+          end
         end
       end
+
+      memoize :qualified, :canonical, :joined, :project_pk
     end
   end
 end
-
-require 'rom/sql/schema/dsl'

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

@@ -1,5 +1,6 @@
 require 'dry/core/inflector'
-require 'rom/sql/association'
+
+require 'rom/associations/definitions'
 
 module ROM
   module SQL
@@ -52,7 +53,7 @@ module ROM
           if options[:through]
             many_to_many(target, options)
           else
-            add(Association::OneToMany.new(source, target, options))
+            add(::ROM::Associations::Definitions::OneToMany.new(source, target, options))
           end
         end
         alias_method :has_many, :one_to_many
@@ -77,7 +78,7 @@ module ROM
           if options[:through]
             one_to_one_through(target, options)
           else
-            add(Association::OneToOne.new(source, target, options))
+            add(::ROM::Associations::Definitions::OneToOne.new(source, target, options))
           end
         end
 
@@ -90,7 +91,7 @@ module ROM
         #
         # @api public
         def one_to_one_through(target, options = {})
-          add(Association::OneToOneThrough.new(source, target, options))
+          add(::ROM::Associations::Definitions::OneToOneThrough.new(source, target, options))
         end
 
         # Establish a many-to-many association
@@ -107,7 +108,7 @@ module ROM
         #
         # @api public
         def many_to_many(target, options = {})
-          add(Association::ManyToMany.new(source, target, options))
+          add(::ROM::Associations::Definitions::ManyToMany.new(source, target, options))
         end
 
         # Establish a many-to-one association
@@ -124,7 +125,7 @@ module ROM
         #
         # @api public
         def many_to_one(target, options = {})
-          add(Association::ManyToOne.new(source, target, options))
+          add(::ROM::Associations::Definitions::ManyToOne.new(source, target, options))
         end
 
         # Shortcut for many_to_one which sets alias automatically

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

@@ -0,0 +1,164 @@
+require 'dry/core/class_attributes'
+
+module ROM
+  module SQL
+    class Schema < ROM::Schema
+      # @api private
+      class AttributesInferrer
+        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
+
+        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 :attr_class, optional: true
+
+        # @api private
+        def call(schema, gateway)
+          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])
+
+            attr_class.new(type.meta(name: name, source: schema.name)) if type
+          end.compact
+
+          missing = columns.map(&:first) - inferred.map { |attr| attr.meta[:name] }
+
+          [inferred, missing]
+        end
+
+        # @api private
+        def with(new_options)
+          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
+end