rom-sql 3.1.0 → 3.3.3

data/lib/rom/sql/attribute_aliasing.rb

@@ -21,6 +21,34 @@ module ROM
       end
       alias as aliased
 
+
+      # Return true if this attribute is an aliased projection
+      #
+      # @example
+      #   class Tasks < ROM::Relation[:memory]
+      #     schema do
+      #       attribute :user_id, Types::Integer, alias: :id
+      #       attribute :name, Types::String
+      #     end
+      #   end
+      #
+      #   Users.schema[:user_id].aliased?
+      #   # => true
+      #   Users.schema[:user_id].aliased_projection?
+      #   # => false
+      #
+      #   Users.schema[:user_id].qualified_projection.aliased?
+      #   # => true
+      #   Users.schema[:user_id].qualified_projection.aliased_projection?
+      #   # => true
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @api private
+      def aliased_projection?
+        self.meta[:sql_expr].is_a?(Sequel::SQL::AliasedExpression)
+      end
+
       private
 
       # @api private

data/lib/rom/sql/commands.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/commands'
 
 require 'rom/sql/commands/create'

data/lib/rom/sql/commands/create.rb

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

data/lib/rom/sql/commands/delete.rb

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

data/lib/rom/sql/commands/error_wrapper.rb

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

data/lib/rom/sql/commands/update.rb

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

data/lib/rom/sql/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'concurrent/map'
 require 'rom/support/inflector'
 require 'rom/constants'
@@ -27,7 +29,13 @@ module ROM
 
       # @api private
       def call(&block)
-        result = instance_exec(select_relations(block.parameters), &block)
+        arg, kwargs = select_relations(block.parameters)
+
+        if kwargs.nil?
+          result = instance_exec(arg, &block)
+        else
+          result = instance_exec(**kwargs, &block)
+        end
 
         if result.is_a?(::Array)
           result
@@ -82,9 +90,9 @@ module ROM
           keys = parameters.select { |type, _| type == :keyreq }
 
           if keys.empty?
-            relations
+            [relations, nil]
           else
-            keys.each_with_object({}) { |(_, k), rs| rs[k] = relations[k] }
+            [nil, keys.each_with_object({}) { |(_, k), rs| rs[k] = relations[k] }]
           end
         end
       end

data/lib/rom/sql/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ROM
   module SQL
     class Error < StandardError

data/lib/rom/sql/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sequel/deprecated'
 require 'sequel/exceptions'
 

data/lib/rom/sql/extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/core/extensions'
 
 module ROM

data/lib/rom/sql/extensions/active_support_notifications.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sequel/database/logging'
 require 'active_support/notifications'
 

data/lib/rom/sql/extensions/mysql.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'rom/sql/extensions/mysql/type_builder'

data/lib/rom/sql/extensions/mysql/type_builder.rb

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

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

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'rom/sql/extensions/postgres/commands'
 require 'rom/sql/extensions/postgres/types'
 require 'rom/sql/extensions/postgres/type_builder'
 require 'rom/sql/extensions/postgres/type_serializer'
 require 'rom/plugins/relation/sql/postgres/explain'
+require 'rom/plugins/relation/sql/postgres/full_text_search'

data/lib/rom/sql/extensions/postgres/commands.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/commands/create'
 require 'rom/sql/commands/update'
 
@@ -15,7 +17,7 @@ module ROM
           #
           # @api private
           def returning_dataset
-            relation.dataset.returning(*relation.qualified_columns)
+            relation.dataset.returning(*relation.schema.qualified_projection)
           end
         end
 

data/lib/rom/sql/extensions/postgres/type_builder.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module ROM
   module SQL
     module Postgres
       class TypeBuilder < Schema::TypeBuilder
         defines :db_numeric_types, :db_type_mapping, :db_array_type_matcher
 
-        db_numeric_types %w(
+        db_numeric_types %w[
           smallint integer bigint
           decimal numeric real
           double\ precision serial bigserial
-        ).to_set.freeze
+        ].to_set.freeze
 
         db_type_mapping(
           'uuid'  => Types::UUID,
@@ -39,11 +41,11 @@ module ROM
 
         db_array_type_matcher '[]'.freeze
 
-        def map_pk_type(type, db_type, options = {})
+        def map_pk_type(type, db_type, **options)
           if numeric?(type, db_type)
             type = self.class.numeric_pk_type
           else
-            type = map_type(type, db_type, options)
+            type = map_type(type, db_type, **options)
           end
 
           type.meta(primary_key: true)

data/lib/rom/sql/extensions/postgres/type_serializer.rb

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sequel/core'
 
 require 'rom/sql/type_extensions'

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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'sequel/core'
 
-Sequel.extension(*%i(pg_array pg_array_ops))
+Sequel.extension(:pg_array, :pg_array_ops)
 
 require 'rom/sql/extensions/postgres/types/array_types'
 
@@ -120,7 +122,7 @@ module ROM
             Attribute[type].meta(sql_expr: expr.pg_array[idx])
           end
 
-          def any(type, expr, value)
+          def any(_type, expr, value)
             Attribute[SQL::Types::Bool].meta(sql_expr: { value => expr.pg_array.any })
           end
 
@@ -128,7 +130,7 @@ module ROM
             Attribute[SQL::Types::Bool].meta(sql_expr: expr.pg_array.contained_by(type[other]))
           end
 
-          def length(type, expr)
+          def length(_type, expr)
             Attribute[SQL::Types::Integer].meta(sql_expr: expr.pg_array.length)
           end
 
@@ -140,7 +142,7 @@ module ROM
             Attribute[type].meta(sql_expr: expr.pg_array.remove(cast(type, value)))
           end
 
-          def join(type, expr, delimiter = '', null = nil)
+          def join(_type, expr, delimiter = '', null = nil)
             Attribute[SQL::Types::String].meta(sql_expr: expr.pg_array.join(delimiter, null))
           end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/type_extensions'
 
 module ROM
@@ -52,7 +54,7 @@ module ROM
             end
           end
 
-          def build_read_type(db_type, member_type)
+          def build_read_type(_db_type, member_type)
             if member_type && member_type.meta[:read]
               base_read_type.of(member_type.meta[:read])
             else

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

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

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'sequel/core'
 require 'singleton'
 
-Sequel.extension(*%i(pg_json pg_json_ops))
+Sequel.extension(:pg_json, :pg_json_ops)
 
 module ROM
   module SQL
@@ -228,11 +230,11 @@ module ROM
             end
           end
 
-          def get(type, expr, *path)
+          def get(_type, expr, *path)
             Attribute[json_type].meta(sql_expr: wrap(expr)[path_args(path)])
           end
 
-          def get_text(type, expr, *path)
+          def get_text(_type, expr, *path)
             Attribute[SQL::Types::String].meta(sql_expr: wrap(expr).get_text(path_args(path)))
           end
 
@@ -240,7 +242,7 @@ module ROM
 
           def path_args(path)
             case path.size
-            when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+            when 0 then raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'
             when 1 then path[0]
             else path
             end
@@ -254,32 +256,32 @@ module ROM
         TypeExtensions.register(JSONB) do
           include JSONMethods[JSONB, :pg_jsonb.to_proc]
 
-          def contain(type, expr, value)
+          def contain(_type, expr, value)
             Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contains(value))
           end
 
-          def contained_by(type, expr, value)
+          def contained_by(_type, expr, value)
             Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contained_by(value))
           end
 
-          def has_key(type, expr, key)
+          def has_key(_type, expr, key)
             Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).has_key?(key))
           end
 
-          def has_any_key(type, expr, *keys)
+          def has_any_key(_type, expr, *keys)
             Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contain_any(keys))
           end
 
-          def has_all_keys(type, expr, *keys)
+          def has_all_keys(_type, expr, *keys)
             Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contain_all(keys))
           end
 
-          def merge(type, expr, value)
+          def merge(_type, expr, value)
             Attribute[JSONB].meta(sql_expr: wrap(expr).concat(value))
           end
           alias_method :+, :merge
 
-          def delete(type, expr, *path)
+          def delete(_type, expr, *path)
             sql_expr = path.size == 1 ? wrap(expr) - path : wrap(expr).delete_path(path)
             Attribute[JSONB].meta(sql_expr: sql_expr)
           end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/types/values'
 
 module ROM
@@ -222,20 +224,20 @@ module ROM
         #
         #   end
         module LTreeMethods
-          ASCENDANT = ["(".freeze, " @> ".freeze, ")".freeze].freeze
-          FIND_ASCENDANT = ["(".freeze, " ?@> ".freeze, ")".freeze].freeze
-          DESCENDANT = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
-          FIND_DESCENDANT = ["(".freeze, " ?<@ ".freeze, ")".freeze].freeze
-          MATCH_ANY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
-          MATCH_ANY_LQUERY = ["(".freeze, " ?~ ".freeze, ")".freeze].freeze
-          MATCH_LTEXTQUERY = ["(".freeze, " @ ".freeze, ")".freeze].freeze
-          MATCH_ANY_LTEXTQUERY = ["(".freeze, " ?@ ".freeze, ")".freeze].freeze
+          ASCENDANT = ['(', ' @> ', ')'].freeze
+          FIND_ASCENDANT = ['(', ' ?@> ', ')'].freeze
+          DESCENDANT = ['(', ' <@ ', ')'].freeze
+          FIND_DESCENDANT = ['(', ' ?<@ ', ')'].freeze
+          MATCH_ANY = ['(', ' ? ', ')'].freeze
+          MATCH_ANY_LQUERY = ['(', ' ?~ ', ')'].freeze
+          MATCH_LTEXTQUERY = ['(', ' @ ', ')'].freeze
+          MATCH_ANY_LTEXTQUERY = ['(', ' ?@ ', ')'].freeze
 
-          def match(type, expr, query)
+          def match(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: Sequel::SQL::BooleanExpression.new(:'~', expr, query))
           end
 
-          def match_any(type, expr, query)
+          def match_any(_type, expr, query)
             array = build_array_query(query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(MATCH_ANY, expr, array))
           end
@@ -259,31 +261,31 @@ module ROM
         TypeExtensions.register(ROM::SQL::Types::PG::Array('ltree', LTree)) do
           include LTreeMethods
 
-          def contain_any_ltextquery(type, expr, query)
+          def contain_any_ltextquery(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_LTEXTQUERY, expr, query))
           end
 
-          def contain_ancestor(type, expr, query)
+          def contain_ancestor(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, query))
           end
 
-          def contain_descendant(type, expr, query)
+          def contain_descendant(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, query))
           end
 
-          def find_ancestor(type, expr, query)
+          def find_ancestor(_type, expr, query)
             Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::FIND_ASCENDANT, expr, query))
           end
 
-          def find_descendant(type, expr, query)
+          def find_descendant(_type, expr, query)
             Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::FIND_DESCENDANT, expr, query))
           end
 
-          def match_any_lquery(type, expr, query)
+          def match_any_lquery(_type, expr, query)
             Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LQUERY, expr, query))
           end
 
-          def match_any_ltextquery(type, expr, query)
+          def match_any_ltextquery(_type, expr, query)
             Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LTEXTQUERY, expr, query))
           end
         end
@@ -291,29 +293,29 @@ module ROM
         TypeExtensions.register(LTree) do
           include LTreeMethods
 
-          def match_ltextquery(type, expr, query)
+          def match_ltextquery(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_LTEXTQUERY, expr, query))
           end
 
-          def contain_descendant(type, expr, query)
+          def contain_descendant(_type, expr, query)
             array = build_array_query(query, 'ltree')
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, array))
           end
 
-          def descendant(type, expr, query)
+          def descendant(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, query))
           end
 
-          def contain_ascendant(type, expr, query)
+          def contain_ascendant(_type, expr, query)
             array = build_array_query(query, 'ltree')
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, array))
           end
 
-          def ascendant(type, expr, query)
+          def ascendant(_type, expr, query)
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, query))
           end
 
-          def +(type, expr, other)
+          def +(_type, expr, other)
             other_value = case other
                           when ROM::Types::Values::TreePath
                             other