rom-sql 1.3.5 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 930bb93fc7cdf5236b363f9f1f343e400f567e92
-  data.tar.gz: bc4abbac8eedc26e82b4599ce80657ad99dacab5
+  metadata.gz: ff0be19f60330b9224eaf421b85ad113000c1558
+  data.tar.gz: 3ccb799110fbc7543f3e9ef9ebd511193c700ab6
 SHA512:
-  metadata.gz: 672c4a3ed57a3b3d2de8cb996fddfc0819da3de23af2dbdf6fdb6c962f4d2a5eda7e773e2e8768be403ed0643dd620124e0c3ac8f9c1e841e54d44d7887b0757
-  data.tar.gz: 9c0573d506286947956602885042246478f1798ba82622f5574f959a7eca5b2eba4487de670cf3655d2ee50365011f487bca2b506c076fd8f0edf95045f54689
+  metadata.gz: fe36e8c1a886f3231385d3ff9709aa11a4ad13b63b313ec5fd07fc76af0537327184bef102af03c66331750b76d0edfd7838e1ec4e02e8189ac56f91c7749203
+  data.tar.gz: 3192a10d465305f01d780e4db7af846c14c3c09509afb59f5cdad770383234ab59fc80b49431270aa863adeb7a51f7f3867a05c48cdfde084c7ed1ac1ea83a19

data/CHANGELOG.md

@@ -1,18 +1,24 @@
-## v1.3.5 2017-10-12
+## v2.0.0 to-be-released
 
-### Changed
+### Added
 
-* Added compatibility with `dry-types` 0.11  (flash-gordon)
+* Support for schema plugins (flash-gordon)
+* Support for auto migrations (flash-gordon)
 
-[Compare v1.3.4..v1.3.5](https://github.com/rom-rb/rom-sql/compare/v1.3.4...v1.3.5)
+### Changed
 
-## v1.3.4 2017-09-12
+* [BREAKING] based on rom 4.0 now
+* [BREAKING] `Associates` command plugin requires associations now (solnic)
+* `ManyToOne` no longer uses a join (solnic)
+* `AutoCombine` and `AutoWrap` plugins were removed as this functionality is provided by core API (solnic)
 
 ### Fixed
 
-* A warning caused by using `EMPTY_BRACKET` from Sequel (flash-gordon)
+* Self-ref associations work correctly with custom FKs (solnic)
+* Aliased associations with custom FKs work correctly (solnic)
+* Defining a custom dataset block no longer prevents default views like `by_pk` to be defined (solnic)
 
-[Compare v1.3.3..v1.3.4](https://github.com/rom-rb/rom-sql/compare/v1.3.3...v1.3.4)
+[Compare v1.3.3...master](https://github.com/rom-rb/rom-sql/compare/v1.3.3...master)
 
 ## v1.3.3 2017-05-30
 

data/Gemfile

@@ -2,7 +2,13 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rom', git: 'https://github.com/rom-rb/rom.git', branch: 'release-3.0'
+gem 'dry-types', git: 'https://github.com/dry-rb/dry-types', branch: 'master'
+
+gem 'rom', git: 'https://github.com/rom-rb/rom', branch: 'master' do
+  gem 'rom-core'
+  gem 'rom-mapper'
+  gem 'rom-repository', group: :tools
+end
 
 group :test do
   gem 'pry-byebug', platforms: :mri
@@ -25,7 +31,3 @@ group :test do
   gem 'jdbc-sqlite3', platforms: :jruby
   gem 'ruby-oci8', platforms: :mri if ENV['ROM_USE_ORACLE']
 end
-
-group :tools do
-  gem 'rom-repository', git: 'https://github.com/rom-rb/rom-repository.git', branch: 'master'
-end

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

@@ -1,12 +1,11 @@
+require 'rom/support/notifications'
+
 module ROM
   module Plugins
     module Relation
       module SQL
         # Generates methods for restricting relations by their indexed attributes
         #
-        # This plugin must be enabled for the whole adapter, `use` won't work as
-        # schema is not yet available, unless it was defined explicitly.
-        #
         # @example
         #   rom = ROM.container(:sql, 'sqlite::memory') do |config|
         #     config.create_table(:users) do
@@ -26,26 +25,21 @@ module ROM
         #
         # @api public
         module AutoRestrictions
-          EmptySchemaError = Class.new(ArgumentError) do
-            def initialize(klass)
-              super("#{klass} relation has no schema. " \
-                    "Make sure :auto_restrictions is enabled after defining a schema")
-            end
-          end
+          extend Notifications::Listener
+
+          subscribe('configuration.relations.schema.set', adapter: :sql) do |event|
+            schema = event[:schema]
+            relation = event[:relation]
 
-          def self.included(klass)
-            super
-            schema = klass.schema
-            raise EmptySchemaError, klass if schema.nil?
-            methods, mod = restriction_methods(schema)
-            klass.include(mod)
-            methods.each { |meth| klass.auto_curry(meth) }
+            methods, mod = AutoRestrictions.restriction_methods(schema)
+            relation.include(mod)
+            methods.each { |meth| relation.auto_curry(meth) }
           end
 
           def self.restriction_methods(schema)
             mod = Module.new
 
-            indexed_attrs = schema.select { |attr| attr.meta[:index] }
+            indexed_attrs = schema.indexes.map { |index| index.attributes[0] }.uniq
 
             methods = indexed_attrs.map do |attr|
               meth_name = :"by_#{attr.name}"

data/lib/rom/sql.rb

@@ -1,6 +1,6 @@
-require 'dry-equalizer'
+require 'dry/equalizer'
 require 'sequel'
-require 'rom'
+require 'rom/core'
 
 require 'rom/sql/version'
 require 'rom/sql/errors'
@@ -9,6 +9,7 @@ require 'rom/configuration_dsl'
 
 require 'rom/sql/plugins'
 require 'rom/sql/relation'
+require 'rom/sql/associations'
 require 'rom/sql/gateway'
 require 'rom/sql/migration'
 require 'rom/sql/extensions'

data/lib/rom/sql/associations.rb

@@ -0,0 +1,5 @@
+require 'rom/sql/associations/many_to_many'
+require 'rom/sql/associations/many_to_one'
+require 'rom/sql/associations/one_to_many'
+require 'rom/sql/associations/one_to_one'
+require 'rom/sql/associations/one_to_one_through'

data/lib/rom/sql/associations/core.rb

@@ -0,0 +1,20 @@
+module ROM
+  module SQL
+    module Associations
+      # Core SQL association API
+      #
+      # @api private
+      module Core
+        # @api private
+        def preload(target, loaded)
+          source_key, target_key = join_keys.flatten(1)
+
+          target_pks = loaded.pluck(source_key.key)
+          target_pks.uniq!
+
+          target.where(target_key => target_pks)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'rom/associations/many_to_many'
+require 'rom/sql/associations/core'
+
+module ROM
+  module SQL
+    module Associations
+      class ManyToMany < ROM::Associations::ManyToMany
+        include Associations::Core
+
+        # @api public
+        def call(target: self.target)
+          left = join_assoc.(target: target)
+
+          schema =
+            if left.schema.key?(foreign_key)
+              if target != self.target
+                target.schema.merge(join_schema)
+              else
+                left.schema.project(*columns)
+              end
+            else
+              target_schema
+            end.qualified
+
+          relation = left.join(source.name.dataset, join_keys)
+
+          if view
+            apply_view(schema, relation)
+          else
+            schema.(relation)
+          end
+        end
+
+        # @api public
+        def join(type, source = self.source, target = self.target)
+          through_assoc = source.associations[through]
+          joined = through_assoc.join(type, source)
+          joined.__send__(type, target.name.dataset, join_keys).qualified
+        end
+
+        # @api public
+        def join_keys
+          { source_attr => target_attr }
+        end
+
+        # @api public
+        def source_attr
+          source[source_key].qualified
+        end
+
+        # @api public
+        def target_attr
+          join_relation[target_key].qualified
+        end
+
+        # @api private
+        def persist(children, parents)
+          join_tuples = associate(children, parents)
+          join_relation.multi_insert(join_tuples)
+        end
+
+        private
+
+        # @api private
+        def target_schema
+          target.schema.merge(join_schema)
+        end
+
+        # @api private
+        def join_schema
+          join_relation.schema.project(foreign_key)
+        end
+
+        # @api private
+        def columns
+          target_schema.map(&:name)
+        end
+
+        memoize :join_keys, :target_schema, :join_schema, :columns
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'rom/associations/many_to_one'
+require 'rom/sql/associations/core'
+require 'rom/sql/associations/self_ref'
+
+module ROM
+  module SQL
+    module Associations
+      class ManyToOne < ROM::Associations::ManyToOne
+        include Associations::Core
+        include Associations::SelfRef
+
+        # @api public
+        def call(target: self.target, preload: false)
+          if preload
+            schema = target.schema.qualified
+            relation = target
+          else
+            right = source
+
+            target_pk = target.schema.primary_key_name
+            right_fk = target.foreign_key(source.name)
+
+            target_schema = target.schema
+            right_schema = right.schema.project_pk
+
+            schema =
+              if target.schema.key?(right_fk)
+                target_schema
+              else
+                target_schema.merge(right_schema.project_fk(target_pk => right_fk))
+              end.qualified
+
+            relation = target.join(source_table, join_keys)
+          end
+
+          if view
+            apply_view(schema, relation)
+          else
+            schema.(relation)
+          end
+        end
+
+        # @api public
+        def join(type, source = self.source, target = self.target)
+          source.__send__(type, target.name.dataset, join_keys).qualified
+        end
+
+        # @api private
+        def prepare(target)
+          call(target: target, preload: true)
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/associations/one_to_many.rb

@@ -0,0 +1,31 @@
+require 'rom/associations/one_to_many'
+require 'rom/sql/associations/core'
+require 'rom/sql/associations/self_ref'
+
+module ROM
+  module SQL
+    module Associations
+      class OneToMany < ROM::Associations::OneToMany
+        include Associations::Core
+        include Associations::SelfRef
+
+        # @api public
+        def call(target: self.target)
+          schema = target.schema.qualified
+          relation = target.join(source_table, join_keys)
+
+          if view
+            apply_view(schema, relation)
+          else
+            schema.(relation)
+          end
+        end
+
+        # @api public
+        def join(type, source = self.source, target = self.target)
+          source.__send__(type, target.name.dataset, join_keys).qualified
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/{association → associations}/one_to_one.rb

@@ -1,8 +1,9 @@
+require 'rom/sql/associations/one_to_many'
+
 module ROM
   module SQL
-    class Association
+    module Associations
       class OneToOne < OneToMany
-        result :one
       end
     end
   end

data/lib/rom/sql/{association → associations}/one_to_one_through.rb

@@ -1,8 +1,9 @@
+require 'rom/sql/associations/many_to_many'
+
 module ROM
   module SQL
-    class Association
+    module Associations
       class OneToOneThrough < ManyToMany
-        result :one
       end
     end
   end

data/lib/rom/sql/associations/self_ref.rb

@@ -0,0 +1,39 @@
+module ROM
+  module SQL
+    module Associations
+      module SelfRef
+        def self.included(klass)
+          super
+          klass.memoize :join_keys, :source_table, :source_alias, :source_attr, :target_attr
+        end
+
+        # @api public
+        def join_keys
+          { source_attr => target_attr }
+        end
+
+        # @api public
+        def source_attr
+          source[source_key].qualified(source_alias)
+        end
+
+        # @api public
+        def target_attr
+          target[target_key].qualified
+        end
+
+        protected
+
+        # @api private
+        def source_table
+          self_ref? ? Sequel.as(source.name.dataset, source_alias) : source.name.dataset
+        end
+
+        # @api private
+        def source_alias
+          self_ref? ? :"#{source.name.dataset.to_s[0]}_0" : source.name.dataset
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/attribute.rb

@@ -2,6 +2,8 @@ require 'sequel/core'
 require 'dry/core/cache'
 
 require 'rom/schema/attribute'
+
+require 'rom/sql/type_extensions'
 require 'rom/sql/projection_dsl'
 
 module ROM
@@ -12,57 +14,11 @@ module ROM
     class Attribute < ROM::Schema::Attribute
       OPERATORS = %i[>= <= > <].freeze
       NONSTANDARD_EQUALITY_VALUES = [true, false, nil].freeze
+      INDEXED = Set.new([true]).freeze
 
       # Error raised when an attribute cannot be qualified
       QualifyError = Class.new(StandardError)
 
-      # Type-specific methods
-      #
-      # @api public
-      module TypeExtensions
-        class << self
-          # Gets extensions for a type
-          #
-          # @param [Dry::Types::Type] type
-          #
-          # @return [Hash]
-          #
-          # @api public
-          def [](wrapped)
-            type = wrapped.default? ? wrapped.type : wrapped
-            type = type.optional? ? type.right : type
-            @types[type.meta[:database]][type.meta[:db_type]] || 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)
-            extensions = @types[type.meta[:database]]
-            db_type = type.meta[:db_type]
-
-            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) }
-            extensions[db_type] = functions
-          end
-        end
-
-        @types = ::Hash.new do |hash, database|
-          hash[database] = {}
-        end
-      end
-
       extend Dry::Core::Cache
 
       # @api private
@@ -104,12 +60,12 @@ module ROM
       # @return [SQL::Attribute]
       #
       # @api public
-      def qualified
+      def qualified(table_alias = nil)
         return self if qualified?
 
         case sql_expr
         when Sequel::SQL::AliasedExpression, Sequel::SQL::Identifier
-          type = meta(qualified: true)
+          type = meta(qualified: table_alias || true)
           type.meta(sql_expr: type.to_sql_name)
         else
           raise QualifyError, "can't qualify #{name.inspect} (#{sql_expr.inspect})"
@@ -155,7 +111,7 @@ module ROM
       #
       # @api public
       def qualified?
-        meta[:qualified].equal?(true)
+        meta[:qualified].equal?(true) || meta[:qualified].is_a?(Symbol)
       end
 
       # Return a new attribute marked as a FK
@@ -188,9 +144,9 @@ module ROM
       def to_sym
         @_to_sym ||=
           if qualified? && aliased?
-            :"#{source.dataset}__#{name}___#{meta[:alias]}"
+            :"#{table_name}__#{name}___#{meta[:alias]}"
           elsif qualified?
-            :"#{source.dataset}__#{name}"
+            :"#{table_name}__#{name}"
           elsif aliased?
             :"#{name}___#{meta[:alias]}"
           else
@@ -319,9 +275,9 @@ module ROM
       def to_sql_name
         @_to_sql_name ||=
           if qualified? && aliased?
-            Sequel.qualify(source.dataset, name).as(meta[:alias])
+            Sequel.qualify(table_name, name).as(meta[:alias])
           elsif qualified?
-            Sequel.qualify(source.dataset, name)
+            Sequel.qualify(table_name, name)
           elsif aliased?
             Sequel.as(name, meta[:alias])
           else
@@ -329,6 +285,27 @@ module ROM
           end
       end
 
+      # @api public
+      def indexed?
+        !indexes.empty?
+      end
+
+      # @api public
+      def indexes
+        if meta[:index] == true
+          INDEXED
+        else
+          meta[:index] || EMPTY_SET
+        end
+      end
+
+      # @api private
+      def meta_ast
+        meta = super
+        meta[:index] = indexes if indexed?
+        meta
+      end
+
       private
 
       # Return Sequel Expression object for an attribute
@@ -372,6 +349,19 @@ module ROM
           type[value]
         end
       end
+
+      # Return source table name or its alias
+      #
+      # @api private
+      def table_name
+        if qualified? && meta[:qualified].is_a?(Symbol)
+          meta[:qualified]
+        else
+          source.dataset
+        end
+      end
+
+      memoize :joined, :to_sql_name, :table_name, :canonical
     end
   end
 end