torque-postgresql 4.0.1 → 4.1.1

data/lib/torque/postgresql/relation/inheritance.rb

@@ -6,13 +6,33 @@ module Torque
       module Inheritance
 
         # :nodoc:
-        def cast_records_values
-          @values.fetch(:cast_records, FROZEN_EMPTY_ARRAY)
+        def expand_records_values
+          @values.fetch(:expand_records, FROZEN_EMPTY_ARRAY)
         end
         # :nodoc:
-        def cast_records_values=(value)
+        def expand_records_values=(value)
           assert_modifiable!
-          @values[:cast_records] = value
+          @values[:expand_records] = value
+        end
+
+        # :nodoc:
+        def expand_records_eager_load_value
+          @values.fetch(:expand_records_eager_load, nil)
+        end
+        # :nodoc:
+        def expand_records_eager_load_value=(value)
+          assert_modifiable!
+          @values[:expand_records_eager_load] = value
+        end
+
+        # :nodoc:
+        def expand_records_scoped_value
+          @values.fetch(:expand_records_scoped, nil) || {}
+        end
+        # :nodoc:
+        def expand_records_scoped_value=(value)
+          assert_modifiable!
+          @values[:expand_records_scoped] = value
         end
 
         # :nodoc:
@@ -25,6 +45,8 @@ module Torque
           @values[:itself_only] = value
         end
 
+        RECORD_CLASS_TOKEN = :_regclass
+
         delegate :quote_table_name, :quote_column_name, to: :connection
 
         # Specify that the results should come only from the table that the
@@ -38,46 +60,90 @@ module Torque
 
         # Like #itself_only, but modifies relation in place.
         def itself_only!(*)
+          raise_itself_only_conflict! if expand_records_values.present?
+
           self.itself_only_value = true
           self
         end
 
-        # Enables the casting of all returned records. The result will include
-        # all the information needed to instantiate the inherited models
+        # Load the columns that only exist on the inherited tables, so that
+        # records come out complete and writable. Defaults to every dependent
+        # that adds columns
+        #
+        #   Activity.expand_records
+        #   # Runs one additional query per inherited table
         #
-        #   Activity.cast_records
-        #   # The result list will have many different classes, for all
-        #   # inherited models of activities
-        def cast_records(*types, **options)
-          spawn.cast_records!(*types, **options)
+        #   Activity.expand_records(ActivityBook, eager_load: true)
+        #   # Runs a single query using outer joins
+        def expand_records(*types, **options)
+          spawn.expand_records!(*types, **options)
         end
 
-        # Like #cast_records, but modifies relation in place
-        def cast_records!(*types, **options)
-          where!(regclass.pg_cast(:varchar).in(types.map(&:table_name))) if options[:filter]
-          self.select_extra_values += [regclass.as(_record_class_attribute.to_s)]
-          self.cast_records_values = (types.present? ? types : model.casted_dependents.values)
+        # Like #expand_records, but modifies relation in place
+        def expand_records!(*types, eager_load: false, filter: false)
+          raise_itself_only_conflict! if itself_only_value === true
+
+          types = types.presence || model.inheritance_expandable_dependents.values
+
+          where!(regclass.pg_cast(:varchar).in(types.map(&:table_name))) if filter
+          self.expand_records_values = types
+          self.expand_records_eager_load_value = eager_load
           self
         end
 
+        # Accept the record class marker as a column, which is the only way an
+        # explicit selection can still produce casted records
+        #
+        #   Activity.select(:_regclass, :id, :title)
+        def select(*fields)
+          return super if fields.empty?
+          return super(*fields, build_record_class_marker) if fields.delete(RECORD_CLASS_TOKEN)
+
+          super
+        end
+
         private
 
+          def raise_itself_only_conflict!
+            raise InheritanceError.new(<<~MSG.squish)
+              Reading from ONLY a table never returns records from its
+              inherited tables, so itself_only and expand_records cannot be
+              combined.
+            MSG
+          end
+
           # Hook arel build to add any necessary table
           def build_arel(*)
             arel = super
             arel.only if self.itself_only_value === true
-            build_inheritances(arel)
+
+            arel.project(build_record_class_marker) if inheritance_discriminated?
+            build_inheritances(arel) if self.expand_records_eager_load_value
             arel
           end
 
+          def inheritance_discriminated?
+            return false if self.itself_only_value === true
+            return false if select_values.present?
+            return false unless from_clause.empty?
+
+            model.physically_inheritances?
+          end
+
+          def build_record_class_marker
+            regclass.as(_record_class_column_name)
+          end
+
           # Build all necessary data for inheritances
           def build_inheritances(arel)
-            return if self.cast_records_values.empty?
+            return if self.expand_records_values.empty?
 
-            mergeable = inheritance_mergeable_attributes
+            columns = build_inheritances_joins(arel, self.expand_records_values)
+            # The joins are still needed, but an explicit select owns the projection
+            return if columns.empty? || select_values.present?
 
-            columns = build_inheritances_joins(arel, self.cast_records_values)
-            columns = columns.map do |column, arel_tables|
+            mergeable = inheritance_mergeable_attributes
+            projections = columns.map do |column, arel_tables|
               next arel_tables.first[column] if arel_tables.size == 1
 
               if mergeable.include?(column)
@@ -87,8 +153,7 @@ module Torque
               end
             end
 
-            columns.push(build_auto_caster_marker(arel, self.cast_records_values))
-            self.select_extra_values += columns.flatten if columns.any?
+            arel.project(*projections.flatten)
           end
 
           # Build as many left outer join as necessary for each dependent table
@@ -111,15 +176,67 @@ module Torque
             columns
           end
 
-          def build_auto_caster_marker(arel, types)
-            attribute = regclass.pg_cast(:varchar).in(types.map(&:table_name))
-            attribute.as(self.class._auto_cast_attribute.to_s)
-          end
-
           def regclass
             arel_table['tableoid'].pg_cast(:regclass)
           end
 
+        module Expansion
+          def preload_associations(records)
+            super
+            return if expand_records_scoped_value.blank?
+
+            expand_records_scoped_value.each do |base_model, targets|
+              preloaded_association_names.each do |name|
+                reflection = model.reflect_on_association(name)
+                next if reflection.nil? || reflection.polymorphic? || !(reflection.klass <= base_model)
+
+                loaded = records.flat_map { |record| record.association(name).target }
+                PostgreSQL::Inheritance::Expander.new(reflection.klass, loaded.compact, targets).call
+              end
+            end
+          end
+
+          private
+
+            # Records only carry the columns of the queried table, so
+            # expanding has to happen after they have been instantiated
+            def exec_queries
+              records = super
+              warn_about_missing_record_class(records)
+              return records if expand_records_values.empty? || expand_records_eager_load_value
+
+              PostgreSQL::Inheritance::Expander.new(model, records, expand_records_values).call
+              records.each(&:readonly!) if readonly_value
+              records
+            end
+
+            def preloaded_association_names
+              list = preload_values + (eager_loading? ? [] : includes_values)
+              list.flat_map { |entry| entry.is_a?(Hash) ? entry.keys : entry }
+            end
+
+            # Warn once per query that actually lost the real class, instead of
+            # once per explicit select that merely omits the marker
+            def warn_about_missing_record_class(records)
+              return unless model.physically_inheritances?
+              return if itself_only_value === true
+              return if records.empty? || group_values.present? || distinct_value || select_values.empty?
+              return unless from_clause.empty?
+              return if select_values.any? { |value| record_class_marker?(value) }
+
+              warn(<<~MSG.squish)
+                #{model.name} was queried with an explicit select that omits
+                :_regclass, so its records will not be instantiated as their
+                real class.
+              MSG
+            end
+
+            def record_class_marker?(value)
+              return value.right.to_s == _record_class_column_name if value.is_a?(::Arel::Nodes::As)
+              value.is_a?(String) && value.include?(_record_class_column_name)
+            end
+
+        end
       end
     end
   end

data/lib/torque/postgresql/relation/join_series.rb

@@ -87,6 +87,7 @@ module Torque
 
               return yield(result, relation.arel_table) if block_given?
 
+              with = relation.resolve_column(with).first if with.is_a?(Hash)
               with = relation.arel_table[with.to_s] if with.is_a?(Symbol)
               with = with.pg_cast(cast) if cast && with.respond_to?(:pg_cast)
 

data/lib/torque/postgresql/relation/merger.rb

@@ -13,6 +13,7 @@ module Torque
           merge_auxiliary_statements
           merge_inheritance
           merge_buckets
+          merge_segments
 
           relation
         end
@@ -46,18 +47,34 @@ module Torque
             end
           end
 
-          # Merge settings related to inheritance tables
+          # Merge settings related to inheritance tables, going through the
+          # public operations so that their conflicts are still detected
           def merge_inheritance
             return unless relation.is_a?(Relation::Inheritance)
 
-            relation.itself_only_value = true if other.itself_only_value.present?
+            relation.itself_only! if other.itself_only_value.present?
 
-            if other.cast_records_values.present?
-              relation.cast_records_values += other.cast_records_values
-              relation.cast_records_values.uniq!
+            return if other.expand_records_values.blank?
+
+            if relation.model == other.model
+              types = (relation.expand_records_values + other.expand_records_values).uniq
+              relation.expand_records!(*types, eager_load: other.expand_records_eager_load_value)
+            else
+              raise_eager_load_conflict! if other.expand_records_eager_load_value
+
+              relation.expand_records_scoped_value = relation.expand_records_scoped_value
+                .merge(other.model => other.expand_records_values) { |_, a, b| (a + b).uniq }
             end
           end
 
+          def raise_eager_load_conflict!
+            raise InheritanceError.new(<<~MSG.squish)
+              Expanding the records of a different model happens through a
+              preload, which has no query to eager load the inherited tables
+              into, so the two cannot be merged.
+            MSG
+          end
+
           # Merge settings related to buckets
           def merge_buckets
             return unless defined?(Relation::Buckets) && relation.is_a?(Relation::Buckets)
@@ -66,6 +83,14 @@ module Torque
             relation.buckets_value = other.buckets_value
           end
 
+          # Merge the named conditions used to segment calculations
+          def merge_segments
+            return unless defined?(Relation::Segments) && relation.is_a?(Relation::Segments)
+            return if other.segments_value.blank?
+
+            relation.segments_value = relation.segments_value.merge(other.segments_value)
+          end
+
       end
 
       ActiveRecord::Relation::Merger.prepend Merger

data/lib/torque/postgresql/relation/segments.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Relation
+      module Segments
+
+        # :nodoc:
+        def segments_value
+          @values.fetch(:segments, ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH)
+        end
+
+        # :nodoc:
+        def segments_value=(value)
+          assert_modifiable!
+          @values[:segments] = value
+        end
+
+        # Maps names to conditions so that the next calculation returns one
+        # value per name, each aggregate filtered by its condition. Anything
+        # that can become a relation is accepted as a condition, an array
+        # applies each of its items in order, and +nil+ means the aggregate is
+        # not filtered at all. For example:
+        #
+        #   User.segments(all: nil, adults: { age: 18.. }).count
+        #   # Returns { all: 15, adults: 12 }
+        #
+        #   User.group(:role).segments(adults: { age: 18.. }).sum(:age)
+        #   # Returns { 'visitor' => { adults: 480 }, ... }
+        def segments(**map)
+          spawn.segments!(**map)
+        end
+
+        # Like #segments, but modifies relation in place.
+        def segments!(**map)
+          predicates = map.to_h { |name, condition| [name, segment_predicate_for(name, condition)] }
+          self.segments_value = segments_value.merge(predicates)
+          self
+        end
+
+        private
+
+          def execute_simple_calculation(operation, column_name, distinct)
+            return super if segments_value.blank?
+
+            execute_segments_calculation(operation, column_name, distinct)
+          end
+
+          def execute_grouped_calculation(operation, column_name, distinct)
+            return super if segments_value.blank?
+
+            execute_segments_calculation(operation, column_name, distinct)
+          end
+
+          def execute_segments_calculation(operation, column_name, distinct)
+            column_name = primary_key if operation == 'count' && column_name == :all && distinct
+            column = aggregate_column(column_name)
+            aggregate = operation_over_aggregate_column(column, operation, distinct)
+
+            relation = except(:group, :select).distinct!(false)
+            relation.order_values = [] if group_values.empty?
+
+            groups = relation.arel_columns(group_values)
+            relation.group_values = groups
+
+            result = skip_query_cache_if_necessary do
+              klass.with_connection do |connection|
+                relation.select_values = segments_projections(groups, aggregate, connection)
+                connection.select_all(relation.arel, "#{klass.name} Segments", async: @async)
+              end
+            end
+
+            result.then { |data| segments_result(data, groups, column, operation) }
+          end
+
+          def segments_projections(groups, aggregate, connection)
+            tracker = ::ActiveRecord::Calculations::ColumnAliasTracker.new(connection)
+            projections = groups.map do |group|
+              name = tracker.alias_for(connection.visitor.compile(group).downcase)
+              group.as(connection.quote_column_name(name))
+            end
+
+            segments_value.each_with_object(projections) do |(name, predicate), list|
+              node = predicate.nil? ? aggregate.dup : aggregate.filter(predicate)
+              list << node.as(connection.quote_column_name(name.to_s))
+            end
+          end
+
+          def segments_result(data, groups, column, operation)
+            type = column.try(:type_caster) || ::ActiveRecord::Type.default_value
+            type = type.subtype if ::ActiveRecord::Enum::EnumType === type
+
+            key_types = groups.each_with_index.to_h do |group, index|
+              name = data.columns[index]
+              key_type = group.try(:type_caster)
+              key_type ||= type_for(group) { data.column_types.fetch(name, ::ActiveRecord::Type.default_value) }
+              [name, key_type]
+            end
+
+            rows = data.cast_values(key_types)
+            rows = rows.map { |value| [value] } if data.columns.size == 1
+
+            rows = rows.to_h do |row|
+              key = row.take(groups.size)
+              key = key.first if key.size == 1
+
+              values = row.drop(groups.size).map do |value|
+                type_cast_calculated_value(value, operation, type)
+              end
+
+              [key, segments_value.keys.zip(values).to_h]
+            end
+
+            groups.empty? ? rows.values.first : rows
+          end
+
+          def segment_predicate_for(name, condition)
+            return if !condition.is_a?(::ActiveRecord::Relation) && condition.blank?
+
+            items = condition.is_a?(::Array) ? condition : [condition]
+            relation = items.reduce(klass.unscoped) do |result, item|
+              case item
+              when ::ActiveRecord::Relation then result.merge(item)
+              when Symbol then result.public_send(item)
+              when Proc then item.arity.zero? ? result.instance_exec(&item) : item.call(result)
+              else result.where(item)
+              end
+            end
+
+            raise ArgumentError, <<~MSG.squish if relation.where_clause.empty?
+              Segment #{name} does not filter anything, use nil for an unfiltered segment.
+            MSG
+
+            relation.where_clause.ast
+          end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/relation.rb

@@ -13,9 +13,11 @@ module Torque
       include DistinctOn
       include Inheritance
 
-      SINGLE_VALUE_METHODS = %i[itself_only buckets]
+      SINGLE_VALUE_METHODS = %i[
+        itself_only buckets segments expand_records_eager_load expand_records_scoped
+      ]
       MULTI_VALUE_METHODS = %i[
-        select_extra distinct_on auxiliary_statements cast_records
+        select_extra distinct_on auxiliary_statements expand_records
       ]
 
       VALUE_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
@@ -76,7 +78,11 @@ module Torque
         return unless relation
 
         table = predicate_builder.send(:table)
-        if table.associated_with?(relation.to_s)
+        part = part_table_for(table, relation.to_s)
+        return part if part
+
+        associated = AR810 ? table.associated_with(relation.to_s) : table.associated_with?(relation.to_s)
+        if associated
           table.associated_table(relation.to_s).send(:klass)
         else
           raise ArgumentError, "Relation for #{relation} not found on #{klass}"
@@ -87,8 +93,11 @@ module Torque
       # the given column
       def cast_for_condition(column, value)
         column = columns_hash[column.to_s] unless column.is_a?(ARColumn)
-        caster = connection.lookup_cast_type_from_column(column)
-        connection.type_cast(caster.serialize(value))
+
+        klass.with_connection do |connection|
+          caster = connection.lookup_cast_type_for_column(column)
+          connection.type_cast(caster.serialize(value))
+        end
       end
 
       private
@@ -99,6 +108,16 @@ module Torque
           arel
         end
 
+        def part_table_for(table, name)
+          return unless table.has_column?(name)
+
+          type = Adapter::OID.unwrap(table.type(name))
+          handler = PredicateBuilder.handler_for(type)
+          return if handler.nil?
+
+          handler.new(predicate_builder).table_for(table.arel_table[name], type)
+        end
+
       class_methods do
         # Easy and storable way to access the name used to get the record table
         # name when using inheritance tables
@@ -107,11 +126,10 @@ module Torque
             .inheritance.record_class_column_name.to_sym
         end
 
-        # Easy and storable way to access the name used to get the indicate of
-        # auto casting inherited records
-        def _auto_cast_attribute
-          @@auto_cast ||= Torque::PostgreSQL.config
-            .inheritance.auto_cast_column_name.to_sym
+        # The same name as a string, which is how it arrives on every single
+        # row that has to be discriminated
+        def _record_class_column_name
+          @@record_class_column_name ||= _record_class_attribute.to_s.freeze
         end
       end
 
@@ -138,12 +156,14 @@ module Torque
     # the operation of ActiveRecord Relation
     ActiveRecord::Relation.include Relation
     ActiveRecord::Relation.prepend Relation::Initializer
+    ActiveRecord::Relation.prepend Relation::Inheritance::Expansion
 
     ActiveRecord::Relation::SINGLE_VALUE_METHODS.concat(Relation::SINGLE_VALUE_METHODS)
     ActiveRecord::Relation::MULTI_VALUE_METHODS.concat(Relation::MULTI_VALUE_METHODS)
     ActiveRecord::Relation::VALUE_METHODS.concat(Relation::VALUE_METHODS)
-    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES.merge(%i[cast_records itself_only
-      distinct_on auxiliary_statements buckets])
+    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES.merge(%i[expand_records itself_only
+      expand_records_eager_load expand_records_scoped distinct_on auxiliary_statements buckets
+      segments])
 
   end
 end

data/lib/torque/postgresql/schema_cache.rb

@@ -74,6 +74,7 @@ module Torque
         @data_sources_model_names.delete name
         @inheritance_dependencies.delete name
         @inheritance_associations.delete name
+        @inheritance_loaded = false
       end
 
       def marshal_dump # :nodoc:

data/lib/torque/postgresql/validations.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Validations
+
+      # Checks if the objects nested into an attribute are valid, adding a
+      # single error to the attribute when any of them is not. It takes the
+      # regular +allow_nil+ and +allow_blank+ options, which is how values that
+      # are merely absent are left out of it
+      #
+      # Example:
+      #   validates :home, nested: true
+      #   validates :settings, nested: true, allow_blank: true
+      class NestedValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          invalid = Array.wrap(value).any? do |item|
+            item.respond_to?(:invalid?) && item.invalid?
+          end
+
+          record.errors.add(attribute, :invalid) if invalid
+        end
+      end
+
+    end
+
+    ::ActiveRecord::Base.include(Validations)
+  end
+end

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '4.0.1'
+    VERSION = '4.1.1'
   end
 end

data/lib/torque/postgresql/versioned_commands/command_migration.rb

@@ -62,7 +62,7 @@ module Torque
         end
       end
 
-      CommandMigration = Struct.new(*%i[filename version op type object_name op_version scope]) do
+      CommandMigration = ::Struct.new(*%i[filename version op type object_name op_version scope]) do
         delegate :execute, to: '@migration'
 
         def initialize(filename, *args)
@@ -131,6 +131,29 @@ module Torque
             execute "DROP TYPE #{name.first.first};"
           end
 
+          # Drop the trigger and any function bundled with it
+          def drop_trigger
+            content = File.read(filename)
+            trigger, table = content.scan(Regexp.new([
+              '^\s*CREATE\s+(?:OR\s+REPLACE\s+)?',
+              "TRIGGER\\s+#{NAME_MATCH}",
+              '.*?\bON\s+',
+              NAME_MATCH,
+            ].join, 'mi')).first
+
+            execute "DROP TRIGGER #{trigger} ON #{table};"
+
+            definitions = content.scan(Regexp.new([
+              '^\s*CREATE\s+(?:OR\s+REPLACE\s+)?',
+              "FUNCTION\\s+#{NAME_MATCH}",
+              '\s*(\([_a-z0-9 ,]*\))?',
+            ].join, 'mi'))
+            return if definitions.empty?
+
+            functions = definitions.map(&:join).join(', ')
+            execute "DROP FUNCTION #{functions};"
+          end
+
           # Drop view or materialized view
           def drop_view
             mat, name = File.read(filename).scan(Regexp.new([

data/lib/torque/postgresql/versioned_commands.rb

@@ -117,6 +117,45 @@ module Torque
             MSG
           end
 
+          # Validate that the content of the command is correct
+          def validate_trigger!(content, name)
+            result = content.scan(Regexp.new([
+              '^\s*CREATE\s+(OR\s+REPLACE)?\s*',
+              "TRIGGER\\s+#{NAME_MATCH}",
+            ].join, 'mi'))
+
+            raise ArgumentError, <<~MSG.squish if result.empty?
+              Missing or invalid trigger definition.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if result.size > 1
+              More than one trigger definition found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish unless result.all?(&:first)
+              'OR REPLACE' is required for proper migration support.
+            MSG
+
+            trigger_name = result.first.last.downcase.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if trigger_name != name.downcase
+              Trigger name must match file name.
+            MSG
+
+            functions = content.scan(Regexp.new([
+              '^\s*CREATE\s+(OR\s+REPLACE)?\s*',
+              "FUNCTION\\s+#{NAME_MATCH}",
+            ].join, 'mi'))
+            return if functions.empty?
+
+            raise ArgumentError, <<~MSG.squish if functions.map(&:last).uniq(&:downcase).many?
+              Only one function can be bundled with a trigger.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish unless functions.all?(&:first)
+              'OR REPLACE' is required for proper migration support.
+            MSG
+          end
+
           # Validate that the content of the command is correct
           def validate_view!(content, name)
             result = content.scan(Regexp.new([