rom-sql 3.0.1 → 3.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2019 rom-rb team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,5 +1,5 @@
 [gem]: https://rubygems.org/gems/rom-sql
-[travis]: https://travis-ci.org/rom-rb/rom-sql
+[actions]: https://github.com/rom-rb/rom-sql/actions
 [codeclimate]: https://codeclimate.com/github/rom-rb/rom-sql
 [inchpages]: http://inch-ci.org/github/rom-rb/rom-sql
 [chat]: https://rom-rb.zulipchat.com
@@ -7,7 +7,7 @@
 # rom-sql [![Join the chat at https://rom-rb.zulipchat.com](https://img.shields.io/badge/rom--rb-join%20chat-942283.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/rom-sql.svg)][gem]
-[![Build Status](https://travis-ci.org/rom-rb/rom-sql.svg?branch=master)][travis]
+[![CI Status](https://github.com/rom-rb/rom-sql/workflows/ci/badge.svg)][actions]
 [![Code Climate](https://codeclimate.com/github/rom-rb/rom-sql/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/rom-rb/rom-sql/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/rom-rb/rom-sql.svg?branch=master)][inchpages]
@@ -55,7 +55,7 @@ In order to test the changes, execute:
 
 ```bash
 docker-compose build gem
-docker-compose run --rm gem 'rspec'
+bin/run-specs
 ```
 
 ### Stopping the dependencies

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

@@ -14,6 +14,14 @@ module ROM
 
           target.where(target_key => target_pks)
         end
+
+        # @api private
+        def wrapped
+          new_target = view ? target.send(view) : target
+          to_wrap = self.class.allocate
+          to_wrap.send(:initialize, definition, options.merge(target: new_target))
+          to_wrap.wrap
+        end
       end
     end
   end

data/lib/rom/sql/attribute.rb

@@ -5,6 +5,8 @@ require 'rom/attribute'
 
 require 'rom/sql/type_extensions'
 require 'rom/sql/projection_dsl'
+require 'rom/sql/attribute_wrapping'
+require 'rom/sql/attribute_aliasing'
 
 module ROM
   module SQL
@@ -12,6 +14,9 @@ module ROM
     #
     # @api public
     class Attribute < ROM::Attribute
+      include AttributeWrapping
+      include AttributeAliasing
+
       OPERATORS = %i[>= <= > <].freeze
       NONSTANDARD_EQUALITY_VALUES = [true, false, nil].freeze
       META_KEYS = %i(index foreign_key target sql_expr qualified).freeze
@@ -26,21 +31,6 @@ module ROM
         fetch_or_store(args) { new(*args) }
       end
 
-      # Return a new attribute with an alias
-      #
-      # @example
-      #   users[:id].aliased(:user_id)
-      #
-      # @return [SQL::Attribute]
-      #
-      # @api public
-      def aliased(alias_name)
-        super.with(name: name || alias_name).meta(
-          sql_expr: sql_expr.as(alias_name)
-        )
-      end
-      alias_method :as, :aliased
-
       # Return a new attribute in its canonical form
       #
       # @api public

data/lib/rom/sql/attribute_aliasing.rb

@@ -0,0 +1,60 @@
+# 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
+
+      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/extensions/postgres/types/array.rb

@@ -151,8 +151,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/json.rb

@@ -1,4 +1,5 @@
 require 'sequel/core'
+require 'singleton'
 
 Sequel.extension(*%i(pg_json pg_json_ops))
 
@@ -16,16 +17,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

data/lib/rom/sql/function.rb

@@ -1,4 +1,5 @@
 require 'rom/attribute'
+require 'rom/sql/attribute_wrapping'
 
 module ROM
   module SQL
@@ -6,6 +7,8 @@ module ROM
     #
     # @api public
     class Function < ROM::Attribute
+      include AttributeWrapping
+
       class << self
         # @api private
         def frame_limit(value)
@@ -37,6 +40,19 @@ module ROM
       WINDOW_FRAMES[:rows] = WINDOW_FRAMES[rows: [:start, :current]]
       WINDOW_FRAMES[range: :current] = WINDOW_FRAMES[range: [:current, :current]]
 
+      # Return a new attribute with an alias
+      #
+      # @example
+      #   string::coalesce(users[:name], users[:id]).aliased(:display_name)
+      #
+      # @return [SQL::Function]
+      #
+      # @api public
+      def aliased(alias_name)
+        super.with(name: name || alias_name)
+      end
+      alias_method :as, :aliased
+
       # @api private
       def sql_literal(ds)
         if name

data/lib/rom/sql/gateway.rb

@@ -234,6 +234,9 @@ module ROM
         # this will be default in Sequel 5.0.0 and since we don't rely
         # on dataset mutation it is safe to enable it already
         connection.extension(:freeze_datasets) unless RUBY_ENGINE == 'rbx'
+
+        # for ROM::SQL::Relation#nullify
+        connection.extension(:null_dataset)
       end
 
       # @api private

data/lib/rom/sql/mapper_compiler.rb

@@ -7,11 +7,20 @@ module ROM
         name, _, meta_options = node
 
         if meta_options[:wrapped]
-          [name, from: meta_options[:alias]]
+          [extract_wrapped_name(node), from: meta_options[:alias]]
         else
           [name]
         end
       end
+
+      private
+
+      def extract_wrapped_name(node)
+        _, _, meta_options = node
+        unwrapped_name = meta_options[:alias].to_s.dup
+        unwrapped_name.slice!("#{meta_options[:wrapped]}_")
+        unwrapped_name.to_sym
+      end
     end
   end
 end

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

@@ -0,0 +1,35 @@
+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/plugins.rb

@@ -2,10 +2,12 @@ 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/relation/reading.rb

@@ -807,7 +807,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
@@ -986,7 +995,7 @@ module ROM
         # @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
 
@@ -1002,6 +1011,21 @@ module ROM
           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