torque-postgresql 4.1.0 → 4.1.1

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,7 +13,9 @@ module Torque
       include DistinctOn
       include Inheritance
 
-      SINGLE_VALUE_METHODS = %i[itself_only buckets expand_records_eager_load expand_records_scoped]
+      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 expand_records
       ]
@@ -76,6 +78,9 @@ module Torque
         return unless relation
 
         table = predicate_builder.send(:table)
+        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)
@@ -88,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_for_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
@@ -100,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
@@ -144,7 +162,8 @@ module Torque
     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[expand_records itself_only
-      expand_records_eager_load expand_records_scoped distinct_on auxiliary_statements buckets])
+      expand_records_eager_load expand_records_scoped distinct_on auxiliary_statements buckets
+      segments])
 
   end
 end

data/lib/torque/postgresql/version.rb

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

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

@@ -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([

data/lib/torque/postgresql.rb

@@ -14,8 +14,6 @@ require 'torque/postgresql/config'
 require 'torque/postgresql/version'
 require 'torque/postgresql/collector'
 require 'torque/postgresql/geometry_builder'
-require 'torque/postgresql/attributes/ltree'
-require 'torque/postgresql/attributes/lquery'
 require 'torque/postgresql/predicate_table'
 require 'torque/postgresql/predicate_builder'
 

data/sig/generators/torque/function_generator.rbs

@@ -0,0 +1,9 @@
+module Torque
+  module Generators
+    class FunctionGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_function_file create_migration_file
+    end
+  end
+end

data/sig/generators/torque/skill_generator.rbs

@@ -0,0 +1,7 @@
+module Torque
+  module Generators
+    class SkillGenerator < Rails::Generators::Base
+      def copy_skill: () -> void
+    end
+  end
+end

data/sig/generators/torque/trigger_generator.rbs

@@ -0,0 +1,9 @@
+module Torque
+  module Generators
+    class TriggerGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_trigger_file create_migration_file
+    end
+  end
+end

data/sig/generators/torque/type_generator.rbs

@@ -0,0 +1,9 @@
+module Torque
+  module Generators
+    class TypeGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_type_file create_migration_file
+    end
+  end
+end

data/sig/generators/torque/view_generator.rbs

@@ -0,0 +1,9 @@
+module Torque
+  module Generators
+    class ViewGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_view_file create_migration_file
+    end
+  end
+end

data/sig/manifest.yaml

@@ -0,0 +1,7 @@
+dependencies:
+  - name: delegate
+  - name: date
+  - name: monitor
+  - name: rubygems
+  - name: stringio
+  - name: timeout

data/sig/torque/postgresql/adapter/database_statements.rbs

@@ -0,0 +1,42 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module DatabaseStatements
+        EXTENDED_DATABASE_TYPES: Array[Symbol]
+
+        @_dump_mode: bool
+        @schemas_blacklist: Array[String]
+        @schemas_whitelist: Array[String]
+        @schemas_search_path_sanitized: Array[String]
+
+        def dump_mode!: () -> bool
+        def schemas_blacklist: () -> Array[String]
+        def schemas_whitelist: () -> Array[String]
+        def schemas_search_path_sanitized: () -> Array[String]
+        def valid_type?: (Symbol | String type) -> bool
+        def extended_types: () -> Array[Symbol]
+        def schema_exists?: (table_ref name, ?filtered: bool) -> bool
+        def type_exists?: (table_ref name) -> bool
+        alias data_type_exists? type_exists?
+        def initialize_type_map: (?untyped m) -> untyped
+        def load_additional_types: (?Array[Integer]? oids) -> untyped
+        def torque_load_additional_types: (?Array[Integer]? oids) -> untyped
+        def torque_load_additional_types?: () -> bool
+        def composite_column_types: (table_ref name) -> Hash[String, type_caster]
+        def composite_types: () -> Array[String]
+        def user_defined_types: (*String? categories) -> Hash[String, String]
+        def inherited_tables: () -> Hash[String, Array[String]]
+        def user_defined_schemas: () -> Array[String]
+        def user_defined_schemas_sql: () -> String
+        def column_definitions: (table_ref table_name) -> Array[Array[untyped]]
+        def list_versioned_commands: (Symbol type) -> Array[[String, String]]
+        def filter_by_schema: () -> Array[String]
+
+        private
+
+        def composite_type_dependencies: () -> Hash[String, Array[String]]
+        def sort_composite_type: (String name, Hash[String, Array[String]] dependencies, Array[String] result) -> Array[String]?
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/inheritance_statements.rbs

@@ -0,0 +1,36 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module InheritanceStatements
+        type features = Hash[Symbol, bool]
+        type tree = Array[[String, Array[String]]]
+
+        SYNC_MARKER: String
+        SYNC_FEATURES: Array[Symbol]
+
+        def sync_inheritance_features: (table_ref table_name, ?table_ref | Array[table_ref] | nil children, ?prune: bool, **bool features) -> tree
+
+        private
+
+        def sync_inheritance_tree: (table_ref table_name, table_ref | Array[table_ref] | nil children) -> tree
+        def sync_inheritance_descendants: (Hash[String, Array[String]] dependencies, String table_name) -> Array[String]
+        def sync_inheritance_selection: (Hash[Symbol, bool] | bool features) -> features
+        def sync_inheritance_into: (String child, Array[String] parents, features features, bool prune) -> untyped
+        def sync_inheritance_primary_key: (String child, Array[String] parents) -> untyped
+        def sync_inheritance_indexes: (String child, Array[String] parents, features features, bool prune) -> untyped
+        def sync_inheritance_unique_constraints: (String child, Array[String] parents, bool prune) -> untyped
+        def sync_inheritance_exclusion_constraints: (String child, Array[String] parents, bool prune) -> untyped
+        def sync_inheritance_foreign_keys: (String child, Array[String] parents, bool prune) -> untyped
+        def sync_inheritance_name: (String child, String parent, String source) -> String
+        def sync_inheritance_copy?: (String | Symbol name) -> bool
+        def sync_inheritance_stale: (Array[untyped] existing, Hash[String, untyped] expected) -> Array[String]
+        def sync_inheritance_constraint_indexes: (String table_name, ?features? features) -> Array[String]
+        def sync_inheritance_index_options: (ActiveRecord::ConnectionAdapters::IndexDefinition index) -> Hash[Symbol, untyped]
+        def sync_inheritance_index?: (ActiveRecord::ConnectionAdapters::IndexDefinition current, ActiveRecord::ConnectionAdapters::IndexDefinition source) -> bool
+        def sync_inheritance_exclusion?: (untyped current, untyped source) -> bool
+        def sync_inheritance_foreign_key?: (untyped current, untyped source) -> bool
+        def sync_inheritance_parent_primary_key?: (table_ref table_name) -> bool
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/array.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        module Array
+          def force_equality?: (untyped value) -> bool
+
+          private
+
+          def type_cast_array: (untyped value, Symbol method) -> untyped
+          def path_subtype?: () -> bool
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array[unchecked out Elem]
+  prepend Torque::PostgreSQL::Adapter::OID::Array
+end

data/sig/torque/postgresql/adapter/oid/box.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    class Box < ::Struct[untyped]
+      def x1: () -> Numeric
+      def x1=: (Numeric value) -> Numeric
+      def y1: () -> Numeric
+      def y1=: (Numeric value) -> Numeric
+      def x2: () -> Numeric
+      def x2=: (Numeric value) -> Numeric
+      def y2: () -> Numeric
+      def y2=: (Numeric value) -> Numeric
+
+      def points: () -> Array[untyped]
+    end
+
+    module Adapter
+      module OID
+        class Box < Torque::PostgreSQL::GeometryBuilder
+          PIECES: ::Array[Symbol]
+          FORMATION: String
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Box < Torque::PostgreSQL::Box
+end

data/sig/torque/postgresql/adapter/oid/circle.rbs

@@ -0,0 +1,33 @@
+module Torque
+  module PostgreSQL
+    class Circle < ::Struct[untyped]
+      def x: () -> Numeric
+      def x=: (Numeric value) -> Numeric
+      def y: () -> Numeric
+      def y=: (Numeric value) -> Numeric
+      def r: () -> Numeric
+      def r=: (Numeric value) -> Numeric
+      alias radius r
+      alias radius= r=
+
+      def center: () -> untyped
+      def center=: (untyped value) -> Numeric
+
+      private
+
+      def point_class: () -> Class
+    end
+
+    module Adapter
+      module OID
+        class Circle < Torque::PostgreSQL::GeometryBuilder
+          PIECES: ::Array[Symbol]
+          FORMATION: String
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Circle < Torque::PostgreSQL::Circle
+end

data/sig/torque/postgresql/adapter/oid/composite.rbs

@@ -0,0 +1,35 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Composite < ActiveModel::Type::Value
+          ARRAY: singleton(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array)
+          DATA: untyped
+          ENCODER: untyped
+          DECODER: untyped
+
+          attr_reader name: String
+
+          def self.from: (untyped type) -> Composite?
+          def self.create: (Hash[String, untyped] row, ActiveRecord::Type::HashLookupTypeMap type_map) -> untyped
+          def initialize: (table_ref name) -> void
+          def klass: () -> singleton(Attributes::Composite)
+          def columns: () -> Hash[String, type_caster]
+          def type: () -> :composite
+          def cast: (untyped value) -> untyped
+          def deserialize: (untyped value) -> Attributes::Composite?
+          def serialize: (untyped value) -> untyped
+          def changed_in_place?: (untyped raw_old_value, untyped new_value) -> bool
+          def ==: (untyped other) -> bool
+          alias eql? ==
+          def hash: () -> Integer
+
+          private
+
+          def build: (Hash[column_ref, untyped] attrs) -> Attributes::Composite
+          def attributes_of: (Attributes::Composite record) -> ActiveModel::AttributeSet
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/enum.rbs

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Enum < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum
+          type row = Hash[String, untyped]
+
+          attr_reader name: String
+          attr_reader klass: singleton(Attributes::Enum) | singleton(Attributes::EnumSet)
+          attr_reader set_klass: EnumSet?
+          attr_reader enum_klass: Enum | singleton(Attributes::Enum)
+
+          def self.create: (row row, ActiveRecord::Type::HashLookupTypeMap type_map) -> untyped
+          def initialize: (String name) -> void
+          def hash: () -> Integer
+          def serialize: (untyped value) -> String?
+          def assert_valid_value: (untyped value) -> untyped
+          def type_cast_for_schema: (untyped value) -> String
+          def ==: (untyped other) -> bool
+
+          private
+
+          def cast_value: (untyped value) -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/enum_set.rbs

@@ -0,0 +1,19 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class EnumSet < Enum
+          def initialize: (String name, singleton(Attributes::Enum) enum_klass) -> void
+          def type: () -> :enum
+          def deserialize: (untyped value) -> untyped
+          def serialize: (untyped value) -> String?
+          def type_cast_for_schema: (untyped value) -> String
+
+          private
+
+          def cast_value: (untyped value) -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/interval.rbs

@@ -0,0 +1,20 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Interval < ActiveModel::Type::Value
+          CAST_PARTS: ::Array[Symbol]
+
+          def type: () -> :interval
+          def cast: (untyped value) -> untyped
+          def deserialize: (String? value) -> ActiveSupport::Duration?
+          def serialize: (untyped value) -> String?
+          def type_cast_for_schema: (untyped value) -> String
+          def assert_valid_value: (untyped value) -> nil
+          def parts_to_duration: (Hash[untyped, untyped] | ::Array[untyped] parts) -> ActiveSupport::Duration
+          def remove_weeks: (ActiveSupport::Duration value) -> ActiveSupport::Duration
+        end
+      end
+    end
+  end
+end

data/sig/torque/postgresql/adapter/oid/line.rbs

@@ -0,0 +1,33 @@
+module Torque
+  module PostgreSQL
+    class Line < ::Struct[untyped]
+      def slope: () -> (Rational | Float)
+      def slope=: (Rational | Float value) -> (Rational | Float)
+      def intercept: () -> Numeric
+      def intercept=: (Numeric value) -> Numeric
+      alias c intercept
+      alias c= intercept=
+
+      def a=: (Numeric value) -> (Rational | Float)
+      def a: () -> Numeric
+      def b=: (Numeric value) -> (Rational | Float)
+      def b: () -> Numeric
+      def horizontal?: () -> bool
+      def vertical?: () -> bool
+    end
+
+    module Adapter
+      module OID
+        class Line < Torque::PostgreSQL::GeometryBuilder
+          PIECES: ::Array[Symbol]
+          FORMATION: String
+
+          def build_klass: (*untyped args) -> untyped
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Line < Torque::PostgreSQL::Line
+end