rom-sql 2.5.0 → 3.3.0

data/lib/rom/sql/attribute_aliasing.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ROM
+  module SQL
+    # @api private
+    module AttributeAliasing
+      # Return a new attribute with an alias
+      #
+      # @example
+      #   users[:id].aliased(:user_id)
+      #
+      # @return [SQL::Attribute]
+      #
+      # @api public
+      def aliased(alias_name)
+        new_name, new_alias_name = extract_alias_names(alias_name)
+
+        super(new_alias_name).with(name: new_name).meta(
+          sql_expr: alias_sql_expr(sql_expr, new_alias_name)
+        )
+      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
+      def alias_sql_expr(sql_expr, new_alias)
+        case sql_expr
+        when Sequel::SQL::AliasedExpression
+          Sequel::SQL::AliasedExpression.new(sql_expr.expression, new_alias, sql_expr.columns)
+        else
+          sql_expr.as(new_alias)
+        end
+      end
+
+      # @api private
+      def extract_alias_names(alias_name)
+        new_name, new_alias_name = nil
+
+        if wrapped? && aliased?
+          # If the attribute is wrapped *and* aliased, make sure that we name the
+          # attribute in a way that will map the the requested alias name.
+          # Without this, the attribute will silently ignore the requested alias
+          # name and default to the pre-existing name.
+          new_name = "#{meta[:wrapped]}_#{options[:alias]}".to_sym
+
+          # Essentially, this makes it so "wrapped" attributes aren't true
+          # aliases, in that we actually alias the wrapped attribute, we use
+          # the old alias.
+          new_alias_name = options[:alias]
+        else
+          new_name = name || alias_name
+          new_alias_name = alias_name
+        end
+
+        [new_name, new_alias_name]
+      end
+    end
+  end
+end

data/lib/rom/sql/attribute_wrapping.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ROM
+  module SQL
+    # @api private
+    module AttributeWrapping
+      # Return if the attribute type is from a wrapped relation
+      #
+      # Wrapped attributes are used when two schemas from different relations
+      # are merged together. This way we can identify them easily and handle
+      # correctly in places like auto-mapping.
+      #
+      # @api public
+      def wrapped?
+        !meta[:wrapped].nil?
+      end
+
+      # Return attribute type wrapped for the specified relation name
+      #
+      # @param [Symbol] name The name of the source relation (defaults to source.dataset)
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def wrapped(name = source.dataset)
+        meta(wrapped: name).prefixed(name)
+      end
+    end
+  end
+end

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,6 @@
+# frozen_string_literal: true
+
+require 'concurrent/map'
 require 'rom/support/inflector'
 require 'rom/constants'
 
@@ -13,15 +16,26 @@ 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)
+        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
@@ -41,6 +55,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 +83,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, nil]
+          else
+            [nil, keys.each_with_object({}) { |(_, k), rs| rs[k] = relations[k] }]
+          end
+        end
+      end
     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,9 @@
+# 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'
+require "rom/plugins/relation/sql/postgres/streaming"

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'
 
@@ -66,7 +68,7 @@ module ROM
         #     # @!method length
         #     #   Return array size
         #     #
-        #     #   @return [SQL::Attribute<Types::Int>]
+        #     #   @return [SQL::Attribute<Types::Integer>]
         #     #
         #     #   @api public
         #
@@ -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,8 +130,8 @@ module ROM
             Attribute[SQL::Types::Bool].meta(sql_expr: expr.pg_array.contained_by(type[other]))
           end
 
-          def length(type, expr)
-            Attribute[SQL::Types::Int].meta(sql_expr: expr.pg_array.length)
+          def length(_type, expr)
+            Attribute[SQL::Types::Integer].meta(sql_expr: expr.pg_array.length)
           end
 
           def overlaps(type, expr, other_array)
@@ -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
 
@@ -151,8 +153,7 @@ module ROM
           private
 
           def cast(type, value)
-            db_type = type.optional? ? type.right.meta[:type] : type.meta[:type]
-            Sequel.cast(value, db_type)
+            Sequel.cast(value, type.meta[:type])
           end
         end
       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,6 +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
@@ -16,16 +19,70 @@ module ROM
           end
         end
 
-        JSON = Type('json') do
-          (SQL::Types::Array | SQL::Types::Hash)
-            .constructor(Sequel.method(:pg_json))
-            .meta(read: JSONRead)
+        class JSONNullType
+          include ::Singleton
+
+          def to_s
+            'null'
+          end
+
+          def inspect
+            'null'
+          end
         end
 
-        JSONB = Type('jsonb') do
-          (SQL::Types::Array | SQL::Types::Hash)
-            .constructor(Sequel.method(:pg_jsonb))
-            .meta(read: JSONRead)
+        JSONNull = JSONNullType.instance.freeze
+
+        if ::Sequel.respond_to?(:pg_json_wrap)
+          primitive_json_types = [
+            SQL::Types::Array,
+            SQL::Types::Hash,
+            SQL::Types::Integer,
+            SQL::Types::Float,
+            SQL::Types::String,
+            SQL::Types::True,
+            SQL::Types::False
+          ]
+
+          JSON = Type('json') do
+            casts = ::Hash.new(-> v { ::Sequel.pg_json(v) })
+            json_null = ::Sequel.pg_json_wrap(nil)
+            casts[JSONNullType] = -> _ { json_null }
+            casts[::NilClass] = -> _ { json_null }
+            primitive_json_types.each do |type|
+              casts[type.primitive] = -> v { ::Sequel.pg_json_wrap(v) }
+            end
+            casts.freeze
+
+            [*primitive_json_types, SQL::Types.Constant(JSONNull)]
+              .reduce(:|)
+              .constructor { |value| casts[value.class].(value) }
+              .meta(read: JSONRead)
+          end
+
+          JSONB = Type('jsonb') do
+            casts = ::Hash.new(-> v { ::Sequel.pg_jsonb(v) })
+            jsonb_null = ::Sequel.pg_jsonb_wrap(nil)
+            casts[JSONNullType] = -> _ { jsonb_null }
+            casts[::NilClass] = -> _ { jsonb_null }
+            primitive_json_types.each do |type|
+              casts[type.primitive] = -> v { ::Sequel.pg_jsonb_wrap(v) }
+            end
+            casts.freeze
+
+            [*primitive_json_types, SQL::Types.Constant(JSONNull)]
+              .reduce(:|)
+              .constructor { |value| casts[value.class].(value) }
+              .meta(read: JSONRead)
+          end
+        else
+          JSON = Type('json') do
+            (SQL::Types::Array | SQL::Types::Hash).constructor(Sequel.method(:pg_json)).meta(read: JSONRead)
+          end
+
+          JSONB = Type('jsonb') do
+            (SQL::Types::Array | SQL::Types::Hash).constructor(Sequel.method(:pg_jsonb)).meta(read: JSONRead)
+          end
         end
 
         # @!parse
@@ -173,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
 
@@ -185,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
@@ -199,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