rom-sql 2.5.0 → 3.3.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ROM
   module SQL
     module Migration

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 require 'rom/types'
@@ -20,7 +22,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 }
 
@@ -65,12 +67,12 @@ module ROM
         end
 
         # @api private
-        def auto_migrate!(gateway, schemas, options = EMPTY_HASH, &block)
+        def auto_migrate!(gateway, schemas, options = EMPTY_HASH)
           diff_finder = SchemaDiff.new(gateway.database_type)
 
           changes = schemas.map { |target|
             empty = SQL::Schema.define(target.name)
-            current = target.with(inferrer.(empty, gateway))
+            current = target.with(**inferrer.(empty, gateway))
 
             diff_finder.(current, target)
           }.reject(&:empty?)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ROM
   module SQL
     module Migration

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ROM
   module SQL
     module Migration
@@ -67,8 +69,8 @@ module ROM
                   if attribute.type_changed?
                     from, to = attribute.current.unwrap, attribute.target.unwrap
                     raise UnsupportedConversion.new(
-                            "Don't know how to convert #{ from.inspect } to #{ to.inspect }"
-                          )
+                      "Don't know how to convert #{from.inspect} to #{to.inspect}"
+                    )
                   end
 
                   if attribute.nullability_changed?

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/type_serializer'
 
 module ROM
@@ -75,8 +77,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/migration/template.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ROM::SQL.migration do
   change do
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/migration/recorder'
 
 module ROM
@@ -32,7 +34,7 @@ module ROM
           operations.each do |operation|
             op, args, nested = operation
             buffer << indent << op.to_s << ' '
-            write_arguments(buffer, *args)
+            write_arguments(buffer, args)
 
             if !nested.empty?
               buffer << ' do'
@@ -42,9 +44,15 @@ module ROM
           end
         end
 
-        def write_arguments(buffer, *args, **kwargs)
+        def write_arguments(buffer, args)
+          if args.last.is_a?(::Hash)
+            args, options = args[0...-1], args.last
+          else
+            options = EMPTY_HASH
+          end
+
           buffer << args.map(&:inspect).join(', ')
-          kwargs.each do |key, value|
+          options.each do |key, value|
             buffer << ', ' << key.to_s << ': ' << value.inspect
           end
         end
@@ -53,7 +61,7 @@ module ROM
           create_or_alter, args = op
           table_name = args[0]
 
-          "#{ create_or_alter.to_s.sub('_table', '') }_#{ table_name }"
+          "#{create_or_alter.to_s.sub('_table', '')}_#{table_name}"
         end
       end
     end

data/lib/rom/sql/order_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/dsl'
 
 module ROM

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/associations'
 
 module ROM
@@ -48,7 +50,7 @@ module ROM
           # @see ROM::Command::ClassInterface.build
           #
           # @api public
-          def build(relation, options = EMPTY_HASH)
+          def build(relation, **options)
             command = super
 
             configured_assocs = command.configured_associations
@@ -146,8 +148,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/nullify.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ROM
+  module SQL
+    module Plugin
+      # Nullify relation by
+      #
+      # @api public
+      module Nullify
+        if defined? JRUBY_VERSION
+          # Returns a relation that will never issue a query to the database. It
+          # implements the null object pattern for relations.
+          # Dataset#nullify doesn't work on JRuby, hence we fall back to SQL
+          #
+          # @api public
+          def nullify
+            where { `1 = 0` }
+          end
+        else
+          # Returns a relation that will never issue a query to the database. It
+          # implements the null object pattern for relations.
+          #
+          # @see http://sequel.jeremyevans.net/rdoc-plugins/files/lib/sequel/extensions/null_dataset_rb.html
+          # @example result will always be empty, regardless if records exists
+          #   users.where(name: 'Alice').nullify
+          #
+          # @return [SQL::Relation]
+          #
+          # @api public
+          def nullify
+            new(dataset.where { `1 = 0` }.__send__(__method__))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/initializer'
 
 module ROM
@@ -72,6 +74,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/plugins.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 require 'rom/plugins/relation/sql/instrumentation'
 require 'rom/plugins/relation/sql/auto_restrictions'
 
 require 'rom/sql/plugin/associates'
+require 'rom/sql/plugin/nullify'
 require 'rom/sql/plugin/pagination'
 
 ROM.plugins do
   adapter :sql do
+    register :nullify, ROM::SQL::Plugin::Nullify, type: :relation
     register :pagination, ROM::SQL::Plugin::Pagination, type: :relation
     register :associates, ROM::SQL::Plugin::Associates, type: :command
   end

data/lib/rom/sql/projection_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/dsl'
 require 'rom/sql/function'
 
@@ -29,13 +31,13 @@ module ROM
       #   users.select { function(:count, :id).as(:total) }
       #
       # @param [Symbol] name SQL function
-      # @param [Symbol] attr
+      # @param [Symbol] attrs
       #
       # @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 +56,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/rake_task.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'rake'
 load 'rom/sql/tasks/migration_tasks.rake'

data/lib/rom/sql/relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/types'
 require 'rom/sql/schema'
 require 'rom/sql/attribute'
@@ -35,7 +37,7 @@ module ROM
           table = opts[:from].first
 
           if db.table_exists?(table)
-            select(*schema.map(&:qualified)).order(*schema.project(*schema.primary_key_names).qualified)
+            select(*schema.qualified_projection).order(*schema.project(*schema.primary_key_names).qualified)
           else
             self
           end

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

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'rom/support/inflector'
+require 'rom/sql/join_dsl'
 
 module ROM
   module SQL
@@ -147,15 +150,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 +224,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 +394,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 +409,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 +565,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 +615,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 +664,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
@@ -772,7 +809,16 @@ module ROM
         #
         # @api public
         def union(relation, options = EMPTY_HASH, &block)
-          new(dataset.__send__(__method__, relation.dataset, options, &block))
+          # We use the original relation name here if both relations have the
+          # same name. This makes it so if the user at some point references
+          # the relation directly by name later on things won't break in
+          # confusing ways.
+          same_relation = name == relation.name
+          alias_name =  same_relation ? name : "#{name.to_sym}__#{relation.name.to_sym}"
+          opts = { alias: alias_name.to_sym, **options }
+
+          new_schema = schema.qualified(opts[:alias])
+          new_schema.(new(dataset.__send__(__method__, relation.dataset, opts, &block)))
         end
 
         # Checks whether a relation has at least one tuple
@@ -847,8 +893,8 @@ module ROM
         #   @yieldparam relation [Array]
         #
         # @api public
-        def lock(options = EMPTY_HASH, &block)
-          clause = lock_clause(options)
+        def lock(**options, &block)
+          clause = lock_clause(**options)
 
           if block
             transaction do
@@ -944,17 +990,44 @@ 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]
         def query
           attr = schema.to_a[0]
-          subquery = schema.project(attr).(self).dataset.unordered
+          subquery = schema.project(attr).(self).dataset
           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
+
+        # Wrap other relations using association names
+        #
+        # @example
+        #   tasks.wrap(:owner)
+        #
+        # @param [Array<Symbol>] names A list with association identifiers
+        #
+        # @return [Wrap]
+        #
+        # @api public
+        def wrap(*names)
+          others = names.map { |name| associations[name].wrapped }
+          wrap_around(*others)
+        end
+
         private
 
         # Build a locking clause
@@ -965,7 +1038,7 @@ module ROM
           stmt << ' OF ' << Array(of).join(', ') if of
 
           if skip_locked
-            raise ArgumentError, "SKIP LOCKED cannot be used with (NO)WAIT clause" if !wait.nil?
+            raise ArgumentError, 'SKIP LOCKED cannot be used with (NO)WAIT clause' if !wait.nil?
 
             stmt << ' SKIP LOCKED'
           else
@@ -988,6 +1061,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
@@ -999,16 +1074,30 @@ module ROM
         # @api private
         def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &block)
           if other.is_a?(Symbol) || other.is_a?(ROM::Relation::Name)
-            if join_cond.empty?
+            if join_cond.equal?(EMPTY_HASH) && !block
               assoc = associations[other]
               assoc.join(type, self)
+            elsif block
+              __join__(type, other, JoinDSL.new(schema).(&block), opts)
             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.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.dataset.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