rom-sql 2.5.0 → 3.3.0

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
@@ -248,9 +250,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
@@ -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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ipaddr'
 
 module ROM

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sequel/core'
 
 Sequel.extension(:pg_range, :pg_range_ops)
@@ -31,13 +33,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 +77,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/extensions/rails_log_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/log_subscriber'
 
 module ROM

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

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'rom/sql/extensions/sqlite/types'
 require 'rom/sql/extensions/sqlite/type_builder'

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

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

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

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

data/lib/rom/sql/foreign_key.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ROM
   module SQL
     # @api private
@@ -5,7 +7,7 @@ module ROM
       extend Initializer
       include Dry::Equalizer(:attributes, :parent_table, :options)
 
-      DEFAULT_PARENT_KEYS = %i(id).freeze
+      DEFAULT_PARENT_KEYS = %i[id].freeze
 
       param :attributes
 

data/lib/rom/sql/function.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'rom/attribute'
+require 'rom/sql/attribute_wrapping'
 
 module ROM
   module SQL
@@ -6,6 +9,8 @@ module ROM
     #
     # @api public
     class Function < ROM::Attribute
+      include AttributeWrapping
+
       class << self
         # @api private
         def frame_limit(value)
@@ -37,6 +42,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
@@ -48,7 +66,7 @@ module ROM
 
       # @api private
       def name
-        meta[:alias] || super
+        self.alias || super
       end
 
       # @see Attribute#qualified
@@ -60,6 +78,22 @@ module ROM
         )
       end
 
+      # @see Attribute#qualified_projection
+      #
+      # @api private
+      def qualified_projection(table_alias = nil)
+        meta(
+          func: ::Sequel::SQL::Function.new(func.name, *func.args.map { |arg| arg.respond_to?(:qualified_projection) ? arg.qualified_projection(table_alias) : arg })
+        )
+      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 +114,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,16 +166,36 @@ 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
+      # @param condition [Hash,SQL::Attribute] Conditions
       # @yield [block] A block with restrictions
       #
       # @return [SQL::Function]
@@ -158,6 +212,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 args [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/gateway.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 require 'sequel/core'
 
@@ -21,7 +23,7 @@ module ROM
       adapter :sql
 
       CONNECTION_EXTENSIONS = {
-        postgres: %i(pg_array pg_json pg_enum)
+        postgres: %i[pg_array pg_json pg_enum]
       }.freeze
 
       # @!attribute [r] logger
@@ -79,6 +81,7 @@ module ROM
       def initialize(uri, options = EMPTY_HASH)
         @connection = connect(uri, options)
         load_extensions(Array(options[:extensions]))
+        Notifications.trigger("configuration.gateway.connected", connection: @connection)
 
         @options = options
 
@@ -234,6 +237,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
@@ -242,4 +248,6 @@ module ROM
       end
     end
   end
+
+  Configuration.register_event("configuration.gateway.connected")
 end

data/lib/rom/sql/group_dsl.rb

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

data/lib/rom/sql/index.rb

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

data/lib/rom/sql/join_dsl.rb

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

data/lib/rom/sql/mapper_compiler.rb

@@ -1,17 +1,28 @@
+# frozen_string_literal: true
+
 require 'rom/mapper_compiler'
 
 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]
+          [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/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rom/sql/migration/migrator'
 require 'rom/sql/migration/schema_diff'
 
@@ -97,8 +99,8 @@ module ROM
       attr_reader :migrator
 
       # @api private
-      def initialize(uri, options = EMPTY_HASH)
-        @migrator = options.fetch(:migrator) { Migrator.new(connection) }
+      def initialize(_uri, options = EMPTY_HASH)
+        @migrator = create_migrator(options[:migrator])
 
         self.class.instance ||= self
       end
@@ -139,13 +141,28 @@ module ROM
       end
 
       # @api public
-      def auto_migrate!(conf, options = EMPTY_HASH, &block)
+      def auto_migrate!(conf, options = EMPTY_HASH)
         schemas = conf.relation_classes(self).map do |klass|
           klass.schema_proc.call.finalize_attributes!(gateway: self)
         end
 
         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