rom-sql 1.3.5 → 2.0.0.beta1

data/lib/rom/plugins/relation/sql/auto_combine.rb

@@ -1,71 +0,0 @@
-module ROM
-  module Plugins
-    module Relation
-      module SQL
-        # @api private
-        module AutoCombine
-          # @api private
-          def self.included(klass)
-            super
-            klass.class_eval do
-              include(InstanceInterface)
-              extend(ClassInterface)
-            end
-          end
-
-          # @api private
-          module ClassInterface
-            # @api private
-            def inherited(klass)
-              super
-              klass.auto_curry :for_combine
-              klass.auto_curry :preload
-            end
-          end
-
-          # @api private
-          module InstanceInterface
-            # Default methods for fetching combined relation
-            #
-            # This method is used by default by `combine`
-            #
-            # @return [SQL::Relation]
-            #
-            # @api private
-            def for_combine(spec)
-              case spec
-              when ROM::SQL::Association
-                spec.call(__registry__, self).preload(spec)
-              else
-                preload(spec)
-              end
-            end
-
-            # @api private
-            def preload(spec, source)
-              case spec
-              when ROM::SQL::Association::ManyToOne
-                pk = source.source[source.source.primary_key].qualified
-
-                where(pk => source.pluck(pk.name))
-              when Hash, ROM::SQL::Association
-                source_key, target_key = spec.is_a?(Hash) ? spec.flatten(1) : spec.join_keys(__registry__).flatten(1)
-
-                target_pks = source.pluck(source_key.to_sym)
-                target_pks.uniq!
-
-                where(target_key => target_pks)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ROM.plugins do
-  adapter :sql do
-    register :auto_combine, ROM::Plugins::Relation::SQL::AutoCombine, type: :relation
-  end
-end

data/lib/rom/plugins/relation/sql/auto_wrap.rb

@@ -1,62 +0,0 @@
-module ROM
-  module Plugins
-    module Relation
-      module SQL
-        # @api private
-        module AutoWrap
-          # @api private
-          def self.included(klass)
-            super
-            klass.class_eval do
-              include(InstanceInterface)
-              extend(ClassInterface)
-            end
-          end
-
-          # @api private
-          module ClassInterface
-            # @api private
-            def inherited(klass)
-              super
-              klass.auto_curry :for_wrap
-            end
-          end
-
-          # @api private
-          module InstanceInterface
-            # Default methods for fetching wrapped relation
-            #
-            # This method is used by default by `wrap` and `wrap_parents`
-            #
-            # @return [SQL::Relation]
-            #
-            # @api private
-            def for_wrap(keys, name)
-              rel, other =
-                if associations.key?(name)
-                  assoc = associations[name]
-                  other = __registry__[assoc.target.relation]
-
-                  [assoc.join(__registry__, :inner_join, self, other), other]
-                else
-                  # TODO: deprecate this before 2.0
-                  other = __registry__[name]
-                  other_dataset = other.name.dataset
-
-                  [qualified.inner_join(other_dataset, keys), other]
-                end
-
-              rel.schema.merge(other.schema.wrap).qualified.(rel)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ROM.plugins do
-  adapter :sql do
-    register :auto_wrap, ROM::Plugins::Relation::SQL::AutoWrap, type: :relation
-  end
-end

data/lib/rom/sql/association.rb

@@ -1,103 +0,0 @@
-require 'dry/core/constants'
-require 'dry/core/class_attributes'
-
-require 'rom/types'
-require 'rom/initializer'
-require 'rom/sql/qualified_attribute'
-require 'rom/sql/association/name'
-
-module ROM
-  module SQL
-    # Abstract association class
-    #
-    # @api public
-    class Association
-      include Dry::Core::Constants
-      include Dry::Equalizer(:source, :target, :result)
-      extend Initializer
-      extend Dry::Core::ClassAttributes
-
-      defines :result
-
-      # @!attribute [r] source
-      #   @return [ROM::Relation::Name] the source relation name
-      param :source
-
-      # @!attribute [r] target
-      #   @return [ROM::Relation::Name] the target relation name
-      param :target
-
-      # @!attribute [r] relation
-      #   @return [Symbol] an optional relation identifier for the target
-      option :relation, Types::Strict::Symbol, optional: true
-
-      # @!attribute [r] result
-      #   @return [Symbol] either :one or :many
-      option :result, Types::Strict::Symbol, default: -> { self.class.result }
-
-      # @!attribute [r] as
-      #   @return [Symbol] an optional association alias name
-      option :as, Types::Strict::Symbol, default: -> { target.to_sym }
-
-      # @!attribute [r] foreign_key
-      #   @return [Symbol] an optional association alias name
-      option :foreign_key, Types::Optional::Strict::Symbol, optional: true
-
-      # @!attribute [r] view
-      #   @return [Symbol] An optional view that should be used to extend assoc relation
-      option :view, optional: true
-
-      alias_method :name, :as
-
-      # @api public
-      def self.new(source, target, options = EMPTY_HASH)
-        super(
-          Name[source],
-          Name[options[:relation] || target, target, options[:as] || target],
-          options
-        )
-      end
-
-      # @api public
-      def join(relations, type, source = relations[self.source], target = relations[self.target])
-        source.__send__(type, target.name.dataset, join_keys(relations)).qualified
-      end
-
-      # Returns a qualified attribute name for a given dataset
-      #
-      # This is compatible with Sequel's SQL generator and can be used in query
-      # DSL methods
-      #
-      # @param name [ROM::Relation::Name]
-      # @param attribute [Symbol]
-      #
-      # @return [QualifiedAttribute]
-      #
-      # @api public
-      def qualify(name, attribute)
-        QualifiedAttribute[name.to_sym, attribute]
-      end
-
-      # @api protected
-      def apply_view(schema, relation)
-        view_rel = relation.public_send(view)
-        schema.merge(view_rel.schema.qualified).uniq(&:to_sql_name).(view_rel)
-      end
-
-      # @api private
-      def join_key_map(relations)
-        join_keys(relations).to_a.flatten.map(&:to_sym)
-      end
-
-      def self_ref?
-        source.dataset == target.dataset
-      end
-    end
-  end
-end
-
-require 'rom/sql/association/one_to_many'
-require 'rom/sql/association/one_to_one'
-require 'rom/sql/association/many_to_many'
-require 'rom/sql/association/many_to_one'
-require 'rom/sql/association/one_to_one_through'

data/lib/rom/sql/association/many_to_many.rb

@@ -1,119 +0,0 @@
-require 'rom/types'
-
-module ROM
-  module SQL
-    class Association
-      class ManyToMany < Association
-        result :many
-
-        option :through, type: Types::Strict::Symbol.optional
-
-        # @api private
-        def initialize(*)
-          super
-          @through = Relation::Name[
-            options[:through] || options[:through_relation], options[:through]
-          ]
-        end
-
-        # @api public
-        def call(relations, target_rel = nil)
-          join_rel = join_relation(relations)
-          assocs = join_rel.associations
-
-          left = target_rel ? assocs[target].(relations, target_rel) : assocs[target].(relations)
-          right = relations[target.relation]
-
-          left_fk = foreign_key || join_rel.foreign_key(source.relation)
-
-          schema =
-            if left.schema.key?(left_fk)
-              if target_rel
-                target_rel.schema.merge(left.schema.project(left_fk))
-              else
-                left.schema.project(*(right.schema.map(&:name) + [left_fk]))
-              end
-            else
-              right.schema.merge(join_rel.schema.project(left_fk))
-            end.qualified
-
-          relation = left.inner_join(source, join_keys(relations))
-
-          if view
-            apply_view(schema, relation)
-          else
-            schema.(relation)
-          end
-        end
-
-        # @api private
-        def persist(relations, children, parents)
-          join_tuples = associate(relations, children, parents)
-          join_relation = join_relation(relations)
-          join_relation.multi_insert(join_tuples)
-        end
-
-        # @api private
-        def parent_combine_keys(relations)
-          relations[target].associations[source].combine_keys(relations).to_a.flatten(1)
-        end
-
-        # @api public
-        def join(relations, type, source = relations[self.source], target = relations[self.target])
-          through_assoc = source.associations[through]
-          joined = through_assoc.join(relations, type, source)
-          joined.__send__(type, target.name.dataset, join_keys(relations)).qualified
-        end
-
-        # @api public
-        def join_keys(relations)
-          with_keys(relations) { |source_key, target_key|
-            { qualify(source, source_key) => qualify(through, target_key) }
-          }
-        end
-
-        # @api public
-        def combine_keys(relations)
-          Hash[*with_keys(relations)]
-        end
-
-        # @api private
-        def associate(relations, children, parent)
-          ((spk, sfk), (tfk, tpk)) = join_key_map(relations)
-
-          case parent
-          when Array
-            parent.map { |p| associate(relations, children, p) }.flatten(1)
-          else
-            children.map { |tuple|
-              { sfk => tuple.fetch(spk), tfk => parent.fetch(tpk) }
-            }
-          end
-        end
-
-        # @api private
-        def join_relation(relations)
-          relations[through.relation]
-        end
-
-        protected
-
-        # @api private
-        def with_keys(relations, &block)
-          source_key = relations[source.relation].primary_key
-          target_key = foreign_key || relations[through.relation].foreign_key(source.relation)
-          return [source_key, target_key] unless block
-          yield(source_key, target_key)
-        end
-
-        # @api private
-        def join_key_map(relations)
-          left = super
-          right = join_relation(relations).associations[target].join_key_map(relations)
-
-          [left, right]
-        end
-      end
-    end
-  end
-end

data/lib/rom/sql/association/many_to_one.rb

@@ -1,73 +0,0 @@
-module ROM
-  module SQL
-    class Association
-      class ManyToOne < Association
-        result :one
-
-        # @api public
-        def call(relations, left = relations[target.relation])
-          right = relations[source.relation]
-
-          left_pk = left.primary_key
-          right_fk = left.foreign_key(source.relation)
-
-          left_schema = left.schema
-          right_schema = right.schema.project_pk
-
-          schema =
-            if left.schema.key?(right_fk)
-              left_schema
-            else
-              left_schema.merge(right_schema.project_fk(left_pk => right_fk))
-            end.qualified
-
-          relation = left.inner_join(source_table, join_keys(relations))
-
-          if view
-            apply_view(schema, relation)
-          else
-            schema.(relation)
-          end
-        end
-
-        # @api public
-        def combine_keys(relations)
-          Hash[*with_keys(relations)]
-        end
-
-        # @api public
-        def join_keys(relations)
-          with_keys(relations) { |source_key, target_key|
-            { qualify(source_alias, source_key) => qualify(target, target_key) }
-          }
-        end
-
-        # @api private
-        def associate(relations, child, parent)
-          fk, pk = join_key_map(relations)
-          child.merge(fk => parent.fetch(pk))
-        end
-
-        protected
-
-        # @api private
-        def source_table
-          self_ref? ? Sequel.as(source.dataset, source_alias) : source
-        end
-
-        # @api private
-        def source_alias
-          self_ref? ? :"#{source.dataset.to_s[0]}_0" : source
-        end
-
-        # @api private
-        def with_keys(relations, &block)
-          source_key = foreign_key || relations[source.relation].foreign_key(target.relation)
-          target_key = relations[target.relation].primary_key
-          return [source_key, target_key] unless block
-          yield(source_key, target_key)
-        end
-      end
-    end
-  end
-end

data/lib/rom/sql/association/name.rb

@@ -1,78 +0,0 @@
-require 'dry/equalizer'
-require 'rom/relation/name'
-require 'dry/core/cache'
-
-module ROM
-  module SQL
-    class Association
-      class Name
-        include Dry::Equalizer.new(:relation_name, :key)
-
-        extend Dry::Core::Cache
-
-        attr_reader :relation_name
-
-        attr_reader :key
-
-        alias_method :to_sym, :key
-
-        def self.[](*args)
-          fetch_or_store(args) do
-            rel, ds, aliaz = args
-
-            if rel.is_a?(ROM::Relation::Name)
-              new(rel, rel.dataset)
-            elsif rel.is_a?(self)
-              rel
-            elsif aliaz
-              new(ROM::Relation::Name[rel, ds], aliaz)
-            elsif ds.nil?
-              new(ROM::Relation::Name[rel], rel)
-            else
-              new(ROM::Relation::Name[rel, ds], ds)
-            end
-          end
-        end
-
-        def initialize(relation_name, aliaz)
-          @relation_name = relation_name
-          @aliased = relation_name.dataset != aliaz
-          @key = aliased? ? aliaz : relation_name.dataset
-        end
-
-        def aliased?
-          @aliased
-        end
-
-        def inspect
-          if aliased?
-            "#{self.class}(#{relation_name.to_s} as #{key})"
-          else
-            "#{self.class}(#{relation_name.to_s})"
-          end
-        end
-        alias_method :to_s, :inspect
-
-        def dataset
-          relation_name.dataset
-        end
-
-        def relation
-          relation_name.relation
-        end
-
-        def as(aliaz)
-          Name[relation_name.relation, relation_name.dataset, aliaz]
-        end
-
-        def to_sym
-          dataset
-        end
-
-        def sql_literal(ds)
-          ds.literal(aliased? ? Sequel[dataset] : Sequel.as(dataset, key))
-        end
-      end
-    end
-  end
-end