rom-sql 2.5.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a266477f912328221111569376f3dc3a007e2db851d251255279f25a7bbe7b5e
-  data.tar.gz: 440673756558a62398d09882dd3a29e76ea2ea21bb6c50c5c5a006a64d22fdf2
+  metadata.gz: 8e459278c95be56ea5da82ea6c6fec9a5bbc443f0865832cea04d3b1b56fbf5a
+  data.tar.gz: fa89dd7f60db5748c69eb85f804a1f2a9076ccfb22828e7dd9c27a7611c5bc2a
 SHA512:
-  metadata.gz: b9efce415899ce279306fd604cce634c06cd70c06705cef9826ec990dbcee7f3c9fb70adc2a7bdebda62a6a7e2544aab77b06d5c4e3be3bda9c8083fb724dddd
-  data.tar.gz: c784be269b61cfda971a8cc11c8cd0c6f0e4780c21d35c6fc521e7fad38585d59507b77698c3aa8a0f932559704bfba833b54e8506bb0e3fa3fe4620034c4d66
+  metadata.gz: 9496cf5afbb38f14782b9104ce05519b2b35674a6fe1ad799f9f34a7f717ad67f4bb79063720818159ff723789bf15e823f55a3d350e7fb30ab6c93607fb8807
+  data.tar.gz: 7a39e507a4ee369e45693d835a47852b2ccad837251b4b426e41496f63650dccd05038eb4dd47126f88b023e1b49a5fae4a2e4ad7af3745f43fd69c6b31f5142

data/CHANGELOG.md

@@ -1,3 +1,62 @@
+## 3.0.0 2019-04-24
+
+### Added
+
+* Join DSL so that you can use arbitrary conditions when joining relations (flash-gordon)
+  ```ruby
+  users.join(tasks) { |users:, tasks:|
+    tasks[:user_id].is(users[:id]) & users[:name].is('John')
+  }
+  ```
+  You also can use table aliases, however the setup is a bit hairy:
+  ```ruby
+  # self-join "users" with itself using "authors" as an alias
+  authors = users.as(:authors).qualified(:authors)
+  result = users.join(authors) { |users: |
+    users[:id].is(authors[:id])
+  }.select(:name)
+  ```
+* Support for `CASE` expression (wmaciejak + flash-gordon)
+  ```ruby
+  # matching expression result
+  users.select_append { id.case(1 => string('one'), else: string('something else')).as(:one_or_else) }
+
+  # searching for `true` result
+  users.select_append { string::case(id.is(1) => 'one', else: 'else').as(:one_or_else) }
+  ```
+* Relations can be accessed in DSLs with keyword arguments (flash-gordon)
+  ```ruby
+  users.join(posts).select_append { |posts: | posts[:title] }
+  ```
+* Support for `.exists` in the projection DSL (flash-gordon)
+  ```ruby
+  users.select_append { |posts: |
+    exists(posts.where(posts[:user_id] => id)).as(:has_posts)
+  }
+  ```
+ * `Relation#unfiltered` returns an unrestricted relation (removes restrictions from `WHERE` and `HAVING`) (flash-gordon)
+ * Support for `WITHIN GROUP` in the function DSL has been enhanced with block syntax (flash-gordon)
+ ```ruby
+  # previously available version
+  households.project { float::percentile_cont(0.5).within_group(income).as(:percentile) }
+  # using the new syntax
+  households.project { float::percentile_cont(0.5).within_group { income }.as(:percentile) }
+  ```
+ * Support for migrator options ie `ROM::Configuration.new(:sql, migrator: { path: "my_migrations" })` (rawburt)
+ * `Relation#pluck` works with multiple args too (timriley)
+
+### Changed
+
+* [BREAKING] Updated to work with `dry-types 1.0.0` (flash-gordon)
+* [BREAKING] `Types::Int` is now `Types::Integer` (GustavoCaso)
+
+### Fixed
+
+- Using `Relation#inner_join` with has-many-through produces correct query (issue #279) (doriantaylor + solnic)
+- Aliased attributes are handled correctly in `Relation#where` (waiting-for-dev)
+
+[Compare v2.5.0...v3.0.0](https://github.com/rom-rb/rom-sql/compare/v2.5.0...v3.0.0)
+
 ## v2.5.0 2018-06-08
 
 ### Added
@@ -7,7 +66,7 @@
   tasks = relations[:tasks]
   users = relations[:users]
   user_tasks = tasks.where(tasks[:user_id].is(users[:id])
-  tasks_count = user_tasks.select { int::count(id) }
+  tasks_count = user_tasks.select { integer::count(id) }
   users.select_append(tasks_count.as(:tasks_count))
   ```
 
@@ -146,7 +205,7 @@
 * Support for window function calls
 
   ```ruby
-    employees.select { [dep_no, salary, int::avg(salary).over(partition: dep_no, order: id).as(:avg_salary)] }
+    employees.select { [dep_no, salary, integer::avg(salary).over(partition: dep_no, order: id).as(:avg_salary)] }
   ```
 
 * Function result can be negated, also `ROM::SQL::Function#not` was added (flash-gordon)

data/README.md

@@ -34,6 +34,37 @@ Or install it yourself as:
 
     $ gem install rom-sql
 
+## Docker
+
+### Development
+
+In order to have reproducible environment for development, Docker can be used. Provided it's installed, in order to start developing, one can simply execute:
+
+```bash
+docker-compose run --rm gem "bash"
+```
+
+If this is the first time this command is executed, it will take some time to set up the dependencies and build the rom-sql container. This should happen only on first execution and in case dependency images are removed.
+
+After dependencies are set container will be started in a bash shell.
+
+### Testing
+
+In order to test the changes, execute:
+
+```bash
+docker-compose build gem
+docker-compose run --rm gem 'rspec'
+```
+
+### Stopping the dependencies
+
+In order to stop the dependencies, execute:
+
+```bash
+docker-compose down --remove-orphans --volumes
+```
+
 ## License
 
 See `LICENSE` file.

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

@@ -36,8 +36,14 @@ module ROM
         # @api public
         def join(type, source = self.source, target = self.target)
           through_assoc = source.associations[through]
+
+          # first we join source to intermediary
           joined = through_assoc.join(type, source)
-          joined.__send__(type, target.name.dataset, join_keys).qualified
+
+          # then we join intermediary to target
+          target_ds  = target.name.dataset
+          through_jk = through_assoc.target.associations[target_ds].join_keys
+          joined.__send__(type, target_ds, through_jk).qualified
         end
 
         # @api public

data/lib/rom/sql/attribute.rb

@@ -26,8 +26,6 @@ module ROM
         fetch_or_store(args) { new(*args) }
       end
 
-      option :extensions, type: Types::Hash, default: -> { TypeExtensions[type] }
-
       # Return a new attribute with an alias
       #
       # @example
@@ -36,8 +34,10 @@ module ROM
       # @return [SQL::Attribute]
       #
       # @api public
-      def aliased(name)
-        super.meta(name: meta.fetch(:name, name), sql_expr: sql_expr.as(name))
+      def aliased(alias_name)
+        super.with(name: name || alias_name).meta(
+          sql_expr: sql_expr.as(alias_name)
+        )
       end
       alias_method :as, :aliased
 
@@ -46,7 +46,7 @@ module ROM
       # @api public
       def canonical
         if aliased?
-          meta(alias: nil, sql_expr: nil)
+          with(alias: nil).meta(sql_expr: nil)
         else
           self
         end
@@ -62,11 +62,12 @@ module ROM
       # @api public
       def qualified(table_alias = nil)
         return self if qualified? && table_alias.nil?
+        return meta(qualified: false) unless qualifiable?
 
         case sql_expr
         when Sequel::SQL::AliasedExpression, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
-          type = meta(qualified: table_alias || true)
-          type.meta(sql_expr: type.to_sql_name)
+          attr = meta(qualified: table_alias || true)
+          attr.meta(sql_expr: attr.to_sql_name)
         else
           raise QualifyError, "can't qualify #{name.inspect} (#{sql_expr.inspect})"
         end
@@ -114,6 +115,15 @@ module ROM
         meta[:qualified].equal?(true) || meta[:qualified].is_a?(Symbol)
       end
 
+      # Return if an attribute is qualifiable
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def qualifiable?
+        !source.nil?
+      end
+
       # Return a new attribute marked as a FK
       #
       # @return [SQL::Attribute]
@@ -239,7 +249,7 @@ module ROM
       # Create a function DSL from the attribute
       #
       # @example
-      #   users[:id].func { int::count(id).as(:count) }
+      #   users[:id].func { integer::count(id).as(:count) }
       #
       # @return [SQL::Function]
       #
@@ -282,11 +292,11 @@ module ROM
       def to_sql_name
         @_to_sql_name ||=
           if qualified? && aliased?
-            Sequel.qualify(table_name, name).as(meta[:alias])
+            Sequel.qualify(table_name, name).as(self.alias)
           elsif qualified?
             Sequel.qualify(table_name, name)
           elsif aliased?
-            Sequel.as(name, meta[:alias])
+            Sequel.as(name, self.alias)
           else
             Sequel[name]
           end
@@ -305,7 +315,7 @@ module ROM
       end
 
       # @api private
-      def meta_ast
+      def meta_options_ast
         meta = super
         meta[:index] = true if indexed?
         meta
@@ -321,6 +331,40 @@ module ROM
         self.class.new(type.with(meta: cleaned_meta), options)
       end
 
+      # Wrap a value with the type, it allows using attribute and type specific methods
+      # on literals and things like this
+      #
+      # @param [Object] value any SQL-serializable value
+      # @return [SQL::Attribute]
+      #
+      # @api public
+      def value(value)
+        meta(sql_expr: Sequel[value])
+      end
+
+      # Build a case expression based on attribute. See SQL::Function#case
+      # when you don't have a specific expression after the CASE keyword.
+      # Pass the :else keyword to provide the catch-all case, it's mandatory
+      # because of the Sequel's API used underneath.
+      #
+      # @example
+      #   users.select_append { id.case(1 => `'first'`, else: `'other'`).as(:first_or_not) }
+      #
+      # @param [Hash] mapping mapping between SQL expressions
+      # @return [SQL::Attribute]
+      #
+      # @api public
+      def case(mapping)
+        mapping = mapping.dup
+        otherwise = mapping.delete(:else) do
+          raise ArgumentError, 'provide the default case using the :else keyword'
+        end
+
+        type = mapping.values[0].type
+
+        Attribute[type].meta(sql_expr: ::Sequel.case(mapping, otherwise, self))
+      end
+
       private
 
       # Return Sequel Expression object for an attribute
@@ -376,6 +420,11 @@ module ROM
         end
       end
 
+      # @api private
+      def extensions
+        TypeExtensions[type]
+      end
+
       memoize :joined, :to_sql_name, :table_name, :canonical
     end
   end

data/lib/rom/sql/dsl.rb

@@ -1,3 +1,4 @@
+require 'concurrent/map'
 require 'rom/support/inflector'
 require 'rom/constants'
 
@@ -13,15 +14,20 @@ module ROM
       #   @return [Hash, RelationRegistry]
       attr_reader :relations
 
+      # @!attribute [r] picked_relations
+      #   @return [Concurrent::Map]
+      attr_reader :picked_relations
+
       # @api private
       def initialize(schema)
         @schema = schema
         @relations = schema.respond_to?(:relations) ? schema.relations : EMPTY_HASH
+        @picked_relations = ::Concurrent::Map.new
       end
 
       # @api private
       def call(&block)
-        result = instance_exec(relations, &block)
+        result = instance_exec(select_relations(block.parameters), &block)
 
         if result.is_a?(::Array)
           result
@@ -41,6 +47,17 @@ module ROM
         ::Sequel.lit(value)
       end
 
+      # Returns a result of SQL EXISTS clause.
+      #
+      # @example
+      #   users.where { exists(users.where(name: 'John')) }
+      #   users.select_append { |r| exists(r[:posts].where(r[:posts][:user_id] => id)).as(:has_posts) }
+      #
+      # @api public
+      def exists(relation)
+        ::ROM::SQL::Attribute[Types::Bool].meta(sql_expr: relation.dataset.exists)
+      end
+
       # @api private
       def respond_to_missing?(name, include_private = false)
         super || schema.key?(name)
@@ -58,6 +75,19 @@ module ROM
       def types
         ::ROM::SQL::Types
       end
+
+      # @api private
+      def select_relations(parameters)
+        @picked_relations.fetch_or_store(parameters.hash) do
+          keys = parameters.select { |type, _| type == :keyreq }
+
+          if keys.empty?
+            relations
+          else
+            keys.each_with_object({}) { |(_, k), rs| rs[k] = relations[k] }
+          end
+        end
+      end
     end
   end
 end

data/lib/rom/sql/extensions/postgres/types/array.rb

@@ -66,7 +66,7 @@ module ROM
         #     # @!method length
         #     #   Return array size
         #     #
-        #     #   @return [SQL::Attribute<Types::Int>]
+        #     #   @return [SQL::Attribute<Types::Integer>]
         #     #
         #     #   @api public
         #
@@ -129,7 +129,7 @@ module ROM
           end
 
           def length(type, expr)
-            Attribute[SQL::Types::Int].meta(sql_expr: expr.pg_array.length)
+            Attribute[SQL::Types::Integer].meta(sql_expr: expr.pg_array.length)
           end
 
           def overlaps(type, expr, other_array)

data/lib/rom/sql/extensions/postgres/types/ltree.rb

@@ -248,9 +248,9 @@ module ROM
 
           def build_array_query(query, array_type = 'lquery')
             case query
-            when Array
+            when ::Array
               ROM::SQL::Types::PG::Array(array_type)[query]
-            when String
+            when ::String
               ROM::SQL::Types::PG::Array(array_type)[query.split(',')]
             end
           end

data/lib/rom/sql/extensions/postgres/types/range.rb

@@ -31,13 +31,13 @@ module ROM
 
         @range_parsers = {
           int4range: Sequel::Postgres::PGRange::Parser.new(
-            'int4range', SQL::Types::Coercible::Int
+            'int4range', SQL::Types::Coercible::Integer
           ),
           int8range: Sequel::Postgres::PGRange::Parser.new(
-            'int8range', SQL::Types::Coercible::Int
+            'int8range', SQL::Types::Coercible::Integer
           ),
           numrange:  Sequel::Postgres::PGRange::Parser.new(
-            'numrange', SQL::Types::Coercible::Int
+            'numrange', SQL::Types::Coercible::Integer
           ),
           tsrange:   Sequel::Postgres::PGRange::Parser.new(
             'tsrange', ::Time.method(:parse)
@@ -75,7 +75,7 @@ module ROM
         # @api private
         def self.range(name, read_type)
           Type(name) do
-            type = SQL::Types.Definition(Values::Range).constructor do |range|
+            type = SQL::Types.Nominal(Values::Range).constructor do |range|
               format('%s%s,%s%s',
                      range.exclude_begin? ? :'(' : :'[',
                      range.lower,

data/lib/rom/sql/function.rb

@@ -48,7 +48,7 @@ module ROM
 
       # @api private
       def name
-        meta[:alias] || super
+        self.alias || super
       end
 
       # @see Attribute#qualified
@@ -60,6 +60,13 @@ module ROM
         )
       end
 
+      # @see Attribute#qualified?
+      #
+      # @api private
+      def qualified?(table_alias = nil)
+        meta[:func].args.all?(&:qualified?)
+      end
+
       # @see ROM::SQL::Attribute#is
       #
       # @api public
@@ -80,8 +87,8 @@ module ROM
       # @see https://www.postgresql.org/docs/9.6/static/tutorial-window.html
       #
       # @example
-      #   users.select { [id, int::row_number().over(partition: name, order: id).as(:row_no)] }
-      #   users.select { [id, int::row_number().over(partition: [first_name, last_name], order: id).as(:row_no)] }
+      #   users.select { [id, integer::row_number().over(partition: name, order: id).as(:row_no)] }
+      #   users.select { [id, integer::row_number().over(partition: [first_name, last_name], order: id).as(:row_no)] }
       #
       # @example frame variants
       #   # ROWS BETWEEN 3 PRECEDING AND CURRENT ROW
@@ -132,14 +139,34 @@ module ROM
         Attribute[type].meta(sql_expr: ::Sequel.cast(expr, db_type))
       end
 
+      # Add a CASE clause for handling if/then logic. This version of CASE search for the first
+      # branch which evaluates to `true`. See SQL::Attriubte#case if you're looking for the
+      # version that matches an expression result
+      #
+      # @example
+      #   users.select { bool::case(status.is("active") => true, else: false).as(:activated) }
+      #
+      # @param [Hash] mapping mapping between boolean SQL expressions to arbitrary SQL expressions
+      # @return [ROM::SQL::Attribute]
+      #
+      # @api public
+      def case(mapping)
+        mapping = mapping.dup
+        otherwise = mapping.delete(:else) do
+          raise ArgumentError, 'provide the default case using the :else keyword'
+        end
+
+        Attribute[type].meta(sql_expr: ::Sequel.case(mapping, otherwise))
+      end
+
       # Add a FILTER clause to aggregate function (supported by PostgreSQL 9.4+)
       # @see https://www.postgresql.org/docs/current/static/sql-expressions.html
       #
       # Filter aggregate using the specified conditions
       #
       # @example
-      #   users.project { int::count(:id).filter(name.is("Jack")).as(:jacks) }.order(nil)
-      #   users.project { int::count(:id).filter { name.is("John") }).as(:johns) }.order(nil)
+      #   users.project { integer::count(:id).filter(name.is("Jack")).as(:jacks) }.order(nil)
+      #   users.project { integer::count(:id).filter { name.is("John") }).as(:johns) }.order(nil)
       #
       # @param [Hash,SQL::Attribute] Conditions
       # @yield [block] A block with restrictions
@@ -158,6 +185,30 @@ module ROM
         super(conditions)
       end
 
+      # Add a WITHIN GROUP clause to aggregate function (supported by PostgreSQL)
+      # @see https://www.postgresql.org/docs/current/static/sql-expressions.html#SYNTAX-AGGREGATES
+      #
+      # Establishes an order for an ordered-set aggregate, see the docs for more details
+      #
+      # @example
+      #   households.project { fload::percentile_cont(0.5).within_group(income).as(:percentile) }
+      #
+      # @param [Array] A list of expressions for sorting within a group
+      # @yield [block] A block for getting the expressions using the Order DSL
+      #
+      # @return [SQL::Function]
+      #
+      # @api public
+      def within_group(*args, &block)
+        if block
+          group = args + ::ROM::SQL::OrderDSL.new(schema).(&block)
+        else
+          group = args
+        end
+
+        super(*group)
+      end
+
       private
 
       # @api private

data/lib/rom/sql/join_dsl.rb

@@ -0,0 +1,9 @@
+require 'rom/sql/restriction_dsl'
+
+module ROM
+  module SQL
+    # @api private
+    class JoinDSL < RestrictionDSL
+    end
+  end
+end

data/lib/rom/sql/mapper_compiler.rb

@@ -4,10 +4,10 @@ module ROM
   module SQL
     class MapperCompiler < ROM::MapperCompiler
       def visit_attribute(node)
-        name, _, meta = node
+        name, _, meta_options = node
 
-        if meta[:wrapped]
-          [name, from: meta[:alias]]
+        if meta_options[:wrapped]
+          [name, from: meta_options[:alias]]
         else
           [name]
         end

data/lib/rom/sql/migration.rb

@@ -98,7 +98,7 @@ module ROM
 
       # @api private
       def initialize(uri, options = EMPTY_HASH)
-        @migrator = options.fetch(:migrator) { Migrator.new(connection) }
+        @migrator = create_migrator(options[:migrator])
 
         self.class.instance ||= self
       end
@@ -146,6 +146,21 @@ module ROM
 
         migrator.auto_migrate!(self, schemas, options)
       end
+
+      private
+
+      # Create a `Migrator`. If `migrator_option` is a `Hash`, use it as options to `Migrator.new`.
+      #
+      # @api private
+      def create_migrator(migrator_option)
+        return Migrator.new(connection) unless migrator_option
+
+        if migrator_option.is_a?(Hash)
+          Migrator.new(connection, migrator_option)
+        else
+          migrator_option
+        end
+      end
     end
   end
 end

data/lib/rom/sql/migration/migrator.rb

@@ -20,7 +20,7 @@ module ROM
 
         param :connection
 
-        option :path, type: ROM::Types.Definition(Pathname), default: -> { DEFAULT_PATH }
+        option :path, type: ROM::Types.Nominal(Pathname), default: -> { DEFAULT_PATH }
 
         option :inferrer, default: -> { DEFAULT_INFERRER }
 

data/lib/rom/sql/migration/schema_diff.rb

@@ -75,8 +75,8 @@ module ROM
             attr.primary_key?
           end
 
-          def unwrap(type)
-            type.optional? ? SQL::Attribute[type.right].meta(type.meta) : type
+          def unwrap(attr)
+            attr.optional? ? SQL::Attribute[attr.right, attr.options].meta(attr.meta) : attr
           end
         end
 

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

@@ -146,8 +146,7 @@ module ROM
           def with_association(name, opts = EMPTY_HASH)
             self.class.build(
               relation,
-              **options,
-              associations: associations.merge(name => opts)
+              { **options, associations: associations.merge(name => opts) }
             )
           end
         end

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

@@ -72,6 +72,26 @@ module ROM
             (total / per_page.to_f).ceil
           end
 
+          # Return one-based index of first tuple in page
+          #
+          # @return [Integer]
+          #
+          # @api public
+          def first_in_page
+            ((current_page - 1) * per_page) + 1
+          end
+
+          # Return one-based index of last tuple in page
+          #
+          # @return [Integer]
+          #
+          # @api public
+          def last_in_page
+            return total if current_page == total_pages
+
+            current_page * per_page
+          end
+
           # @api private
           def at(dataset, current_page, per_page = self.per_page)
             current_page = current_page.to_i

data/lib/rom/sql/projection_dsl.rb

@@ -34,8 +34,8 @@ module ROM
       # @return [Rom::SQL::Function]
       #
       # @api public
-      def function(name, attr)
-        ::ROM::SQL::Function.new(::ROM::Types::Any, schema: schema).public_send(name, attr)
+      def function(name, *attrs)
+        ::ROM::SQL::Function.new(::ROM::Types::Any, schema: schema).public_send(name, *attrs)
       end
       alias_method :f, :function
 
@@ -54,7 +54,11 @@ module ROM
           type = type(meth)
 
           if type
-            ::ROM::SQL::Function.new(type, schema: schema)
+            if args.empty?
+              ::ROM::SQL::Function.new(type, schema: schema)
+            else
+              ::ROM::SQL::Attribute[type].value(args[0])
+            end
           else
             super
           end

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

@@ -1,4 +1,5 @@
 require 'rom/support/inflector'
+require 'rom/sql/join_dsl'
 
 module ROM
   module SQL
@@ -147,15 +148,19 @@ module ROM
 
         # Pluck values from a specific column
         #
-        # @example
+        # @example Single value
         #   users.pluck(:id)
-        #   # [1, 2, 3]
+        #   # [1, 2]
+        #
+        # @example Multiple values
+        #   users.pluck(:id, :name)
+        #   # [[1, "Jane"] [2, "Joe"]]
         #
         # @return [Array]
         #
         # @api public
-        def pluck(name)
-          select(name).map(name)
+        def pluck(*names)
+          select(*names).map(names.length == 1 ? names.first : names)
         end
 
         # Rename columns in a relation
@@ -217,7 +222,7 @@ module ROM
         #   Project relation using column names and projection DSL
         #
         #   @example using attributes
-        #     users.select(:id) { int::count(id).as(:count) }.group(:id).first
+        #     users.select(:id) { integer::count(id).as(:count) }.group(:id).first
         #     # {:id => 1, :count => 1}
         #
         #     users.select { [id, name] }
@@ -387,7 +392,7 @@ module ROM
         #     users.
         #       qualified.
         #       left_join(tasks).
-        #       select { [id, name, int::count(:tasks__id).as(:task_count)] }.
+        #       select { [id, name, integer::count(:tasks__id).as(:task_count)] }.
         #       group(users[:id].qualified).
         #       having(task_count: 2)
         #       first
@@ -402,7 +407,7 @@ module ROM
         #     users.
         #       qualified.
         #       left_join(tasks).
-        #       select { [id, name, int::count(:tasks__id).as(:task_count)] }.
+        #       select { [id, name, integer::count(:tasks__id).as(:task_count)] }.
         #       group(users[:id].qualified).
         #       having { count(id.qualified) >= 1 }.
         #       first
@@ -558,6 +563,16 @@ module ROM
         #
         #   @param [Relation] relation A relation for join
         #
+        # @overload join(relation, &block)
+        #   Join with another relation using DSL
+        #
+        #   @example
+        #     users.join(tasks) { |users:, tasks:|
+        #       tasks[:user_id].is(users[:id]) & users[:name].is('John')
+        #     }
+        #
+        #   @param [Relation] relation A relation for join
+        #
         # @return [Relation]
         #
         # @api public
@@ -598,6 +613,16 @@ module ROM
         #
         #   @param [Relation] relation A relation for left_join
         #
+        # @overload join(relation, &block)
+        #   Join with another relation using DSL
+        #
+        #   @example
+        #     users.left_join(tasks) { |users:, tasks:|
+        #       tasks[:user_id].is(users[:id]) & users[:name].is('John')
+        #     }
+        #
+        #   @param [Relation] relation A relation for left_join
+        #
         # @return [Relation]
         #
         # @api public
@@ -637,6 +662,16 @@ module ROM
         #
         #   @param [Relation] relation A relation for right_join
         #
+        # @overload join(relation, &block)
+        #   Join with another relation using DSL
+        #
+        #   @example
+        #     users.right_join(tasks) { |users:, tasks:|
+        #       tasks[:user_id].is(users[:id]) & users[:name].is('John')
+        #     }
+        #
+        #   @param [Relation] relation A relation for right_join
+        #
         # @return [Relation]
         #
         # @api public
@@ -944,8 +979,8 @@ module ROM
         # @example adding number of user tasks
         #   tasks = relations[:tasks]
         #   users = relations[:users]
-        #   user_tasks = tasks.where(tasks[:user_id].is(users[:id])
-        #   tasks_count = user_tasks.select { int::count(id) }
+        #   user_tasks = tasks.where(tasks[:user_id].is(users[:id]))
+        #   tasks_count = user_tasks.select { integer::count(id) }
         #   users.select_append(tasks_count.as(:tasks_count))
         #
         # @return [SQL::Attribute]
@@ -955,6 +990,18 @@ module ROM
           SQL::Attribute[attr.type].meta(sql_expr: subquery)
         end
 
+        # Discard restrictions in `WHERE` and `HAVING` clauses
+        #
+        # @example calling .by_pk has no effect
+        #   users.by_pk(1).unfiltered
+        #
+        # @return [SQL::Relation]
+        #
+        # @api public
+        def unfiltered
+          new(dataset.__send__(__method__))
+        end
+
         private
 
         # Build a locking clause
@@ -988,6 +1035,8 @@ module ROM
             if k.is_a?(Symbol) && schema.canonical.key?(k)
               type = schema.canonical[k]
               h[k] = v.is_a?(Array) ? v.map { |e| type[e] } : type[v]
+            elsif k.is_a?(ROM::SQL::Attribute)
+              h[k.canonical] = v
             else
               h[k] = v
             end
@@ -1008,7 +1057,19 @@ module ROM
           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.key].join(type, self, other)
+            if block
+              join_cond = JoinDSL.new(schema).(&block)
+
+              if other.name.aliaz
+                join_opts = { table_alias: other.name.aliaz }
+              else
+                join_opts = EMPTY_HASH
+              end
+
+              new(dataset.__send__(type, other.name.to_sym, join_cond, join_opts))
+            else
+              associations[other.name.key].join(type, self, other)
+            end
           else
             raise ArgumentError, "+other+ must be either a symbol or a relation, #{other.class} given"
           end

data/lib/rom/sql/restriction_dsl.rb

@@ -6,15 +6,7 @@ module ROM
     class RestrictionDSL < DSL
       # @api private
       def call(&block)
-        instance_exec(relations, &block)
-      end
-
-      # Returns a result of SQL EXISTS clause.
-      #
-      # @example
-      #   users.where { exists(users.where(name: 'John')) }
-      def exists(relation)
-        ::ROM::SQL::Attribute[Types::Bool].meta(sql_expr: relation.dataset.exists)
+        instance_exec(select_relations(block.parameters), &block)
       end
 
       private

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

@@ -25,10 +25,10 @@ module ROM
           inferred = columns.map do |(name, definition)|
             type = type_builder.(definition)
 
-            attr_class.new(type.meta(name: name, source: schema.name)) if type
+            attr_class.new(type.meta(source: schema.name), name: name) if type
           end.compact
 
-          missing = columns.map(&:first) - inferred.map { |attr| attr.meta[:name] }
+          missing = columns.map(&:first) - inferred.map { |attr| attr.name }
 
           [inferred, missing]
         end

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

@@ -26,8 +26,10 @@ module ROM
         end
 
         # @api private
-        def call(schema_name, types)
-          attributes = types.map { |type| attr_class.new(type).meta(source: schema_name) }
+        def call(schema_name, attrs)
+          attributes = attrs.map do |attr|
+            attr_class.new(attr[:type], attr[:options] || {}).meta(source: schema_name)
+          end
 
           registry.map { |attr_names, options|
             build_index(attributes, attr_names, options)

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

@@ -22,7 +22,7 @@ module ROM
         DECIMAL_REGEX = /(?:decimal|numeric)\((\d+)(?:,\s*(\d+))?\)/.freeze
 
         ruby_type_mapping(
-          integer: Types::Int,
+          integer: Types::Integer,
           string: Types::String,
           time: Types::Time,
           date: Types::Date,
@@ -37,7 +37,7 @@ module ROM
 
         def call(primary_key:, db_type:, type:, allow_null:, **rest)
           if primary_key
-            map_pk_type(type, db_type, **rest)
+            map_pk_type(type, db_type, rest)
           else
             mapped_type = map_type(type, db_type, rest)
 

data/lib/rom/sql/type_dsl.rb

@@ -11,7 +11,7 @@ module ROM
         if value_type.class < ::Dry::Types::Type
           @definition = value_type
         else
-          @definition = ::ROM::SQL::Types.Definition(value_type)
+          @definition = ::ROM::SQL::Types.Nominal(value_type)
         end
       end
 

data/lib/rom/sql/type_serializer.rb

@@ -21,7 +21,7 @@ module ROM
       defines :mapping
 
       mapping(
-        Types::Int => 'integer',
+        Types::Integer => 'integer',
         Types::String => 'varchar',
         Types::Time => 'timestamp',
         Types::Date => 'date',

data/lib/rom/sql/types.rb

@@ -17,10 +17,10 @@ module ROM
       # @example with a custom type
       #   attribute :user_id, Types.ForeignKey(:users, Types::UUID)
       #
-      # @return [Dry::Types::Definition]
+      # @return [Dry::Types::Nominal]
       #
       # @api public
-      def self.ForeignKey(relation, type = Types::Int.meta(index: true))
+      def self.ForeignKey(relation, type = Types::Integer.meta(index: true))
         super
       end
 
@@ -32,14 +32,14 @@ module ROM
       #     output { Types::Coercible::Hash }
       #   end
       #
-      # @return [Dry::Types::Definition]
+      # @return [Dry::Types::Nominal]
       #
       # @api public
       def self.define(value_type, &block)
         TypeDSL.new(value_type).call(&block)
       end
 
-      Serial = Int.meta(primary_key: true)
+      Serial = Integer.meta(primary_key: true)
 
       Blob = Constructor(Sequel::SQL::Blob, &Sequel::SQL::Blob.method(:new))
 

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '2.5.0'.freeze
+    VERSION = '3.0.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2019-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -44,48 +44,48 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dry-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rom-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -184,6 +184,7 @@ files:
 - lib/rom/sql/gateway.rb
 - lib/rom/sql/group_dsl.rb
 - lib/rom/sql/index.rb
+- lib/rom/sql/join_dsl.rb
 - lib/rom/sql/mapper_compiler.rb
 - lib/rom/sql/migration.rb
 - lib/rom/sql/migration/inline_runner.rb
@@ -231,15 +232,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: SQL databases support for ROM