torque-postgresql 3.4.1 → 4.0.0

data/lib/torque/postgresql/railtie.rb

@@ -4,41 +4,148 @@ module Torque
   module PostgreSQL
     # = Torque PostgreSQL Railtie
     class Railtie < Rails::Railtie # :nodoc:
-
       # Get information from the running rails app
       initializer 'torque-postgresql' do |app|
-        torque_config = Torque::PostgreSQL.config
-        torque_config.eager_load = app.config.eager_load
-
-        # Include enum on ActiveRecord::Base so it can have the correct enum
-        # initializer
-        Torque::PostgreSQL::Attributes::Enum.include_on(ActiveRecord::Base)
-        Torque::PostgreSQL::Attributes::EnumSet.include_on(ActiveRecord::Base)
-        Torque::PostgreSQL::Attributes::Period.include_on(ActiveRecord::Base)
-
-        # Setup belongs_to_many association
-        ActiveRecord::Base.belongs_to_many_required_by_default = torque_config.associations
-          .belongs_to_many_required_by_default
-
-        # Define a method to find enumaerators based on the namespace
-        torque_config.enum.namespace.define_singleton_method(:const_missing) do |name|
-          Torque::PostgreSQL::Attributes::Enum.lookup(name)
-        end
+        ActiveSupport.on_load(:active_record_postgresqladapter) do
+          ActiveSupport.on_load(:active_record) do
+            torque_config = Torque::PostgreSQL.config
+            torque_config.eager_load = app.config.eager_load
 
-        # Define a helper method to get a sample value
-        torque_config.enum.namespace.define_singleton_method(:sample) do |name|
-          Torque::PostgreSQL::Attributes::Enum.lookup(name).sample
-        end
+            # TODO: Only load files that have their features enabled, like CTE
+
+            ar_type = ActiveRecord::Type
+
+            # Setup belongs_to_many association
+            ActiveRecord::Base.belongs_to_many_required_by_default =
+              torque_config.associations.belongs_to_many_required_by_default
+
+            ## General features
+            if torque_config.join_series
+              require_relative 'relation/join_series'
+              Relation.include(Relation::JoinSeries)
+            end
+
+            if torque_config.buckets
+              require_relative 'relation/buckets'
+              Relation.include(Relation::Buckets)
+            end
+
+            ## Schemas Enabled Setup
+            if (config = torque_config.schemas).enabled
+              require_relative 'adapter/schema_overrides'
+            end
+
+            ## CTE Enabled Setup
+            if (config = torque_config.auxiliary_statement).enabled
+              require_relative 'auxiliary_statement'
+              require_relative 'relation/auxiliary_statement'
+              Relation.include(Relation::AuxiliaryStatement)
+
+              # Define the exposed constant for both types of auxiliary statements
+              if config.exposed_class.present?
+                *ns, name = config.exposed_class.split('::')
+                base = ns.present? ? ::Object.const_get(ns.join('::')) : ::Object
+                base.const_set(name, AuxiliaryStatement)
+
+                *ns, name = config.exposed_recursive_class.split('::')
+                base = ns.present? ? ::Object.const_get(ns.join('::')) : ::Object
+                base.const_set(name, AuxiliaryStatement::Recursive)
+              end
+            end
+
+            ## Enum Enabled Setup
+            if (config = torque_config.enum).enabled
+              require_relative 'adapter/oid/enum'
+              require_relative 'adapter/oid/enum_set'
+
+              require_relative 'attributes/enum'
+              require_relative 'attributes/enum_set'
+
+              Attributes::Enum.include_on(ActiveRecord::Base)
+              Attributes::EnumSet.include_on(ActiveRecord::Base)
+
+              ar_type.register(:enum,     Adapter::OID::Enum,    adapter: :postgresql)
+              ar_type.register(:enum_set, Adapter::OID::EnumSet, adapter: :postgresql)
+
+              if config.namespace == false
+                # TODO: Allow enum classes to exist without a namespace
+                config.namespace = PostgreSQL.const_set('Enum', Module.new)
+              else
+                config.namespace ||= ::Object.const_set('Enum', Module.new)
+
+                # Define a method to find enumerators based on the namespace
+                config.namespace.define_singleton_method(:const_missing) do |name|
+                  Attributes::Enum.lookup(name)
+                end
+
+                # Define a helper method to get a sample value
+                config.namespace.define_singleton_method(:sample) do |name|
+                  Attributes::Enum.lookup(name).sample
+                end
+              end
+            end
+
+            ## Geometry Enabled Setup
+            if (config = torque_config.geometry).enabled
+              require_relative 'adapter/oid/box'
+              require_relative 'adapter/oid/circle'
+              require_relative 'adapter/oid/line'
+              require_relative 'adapter/oid/segment'
+
+              ar_type.register(:box,     Adapter::OID::Box,     adapter: :postgresql)
+              ar_type.register(:circle,  Adapter::OID::Circle,  adapter: :postgresql)
+              ar_type.register(:line,    Adapter::OID::Line,    adapter: :postgresql)
+              ar_type.register(:segment, Adapter::OID::Segment, adapter: :postgresql)
+            end
+
+            ## Period Enabled Setup
+            if (config = torque_config.period).enabled
+              require_relative 'attributes/period'
+              Attributes::Period.include_on(ActiveRecord::Base)
+            end
+
+            ## Interval Enabled Setup
+            if (config = torque_config.interval).enabled
+              require_relative 'adapter/oid/interval'
+              ar_type.register(:interval, Adapter::OID::Interval, adapter: :postgresql)
+            end
+
+            ## Full Text Search Enabled Setup
+            if (config = torque_config.full_text_search).enabled
+              require_relative 'attributes/full_text_search'
+              Attributes::FullTextSearch.include_on(ActiveRecord::Base)
+            end
+
+            ## Arel Setup
+            PostgreSQL::Arel.build_operations(torque_config.arel.infix_operators)
+            if (mod = torque_config.arel.expose_function_helper_on&.to_s)
+              parent, _, name = mod.rpartition('::')
+              parent = parent ? parent.constantize : ::Object
+
+              raise ArgumentError, <<~MSG.squish if parent.const_defined?(name)
+                Unable to expose Arel function helper on #{mod} because the constant
+                #{name} is already defined on #{parent}. Please choose a different name.
+              MSG
+
+              parent.const_set(name, PostgreSQL::FN)
+            end
+
+            ## Versioned Commands Setup
+            if (config = torque_config.versioned_commands).enabled
+              require_relative 'versioned_commands'
+
+              ActiveRecord::Schema::Definition.include(Adapter::Definition)
+            end
 
-        # Define the exposed constant for both types of auxiliary statements
-        if torque_config.auxiliary_statement.exposed_class.present?
-          *ns, name = torque_config.auxiliary_statement.exposed_class.split('::')
-          base = ns.present? ? Object.const_get(ns.join('::')) : Object
-          base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement)
+            # Make sure to load all the types that are handled by this gem on
+            # each individual PG connection
+            adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+            ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+              next unless pool.db_config.adapter_class.is_a?(adapter)
 
-          *ns, name = torque_config.auxiliary_statement.exposed_recursive_class.split('::')
-          base = ns.present? ? Object.const_get(ns.join('::')) : Object
-          base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement::Recursive)
+              pool.with_connection { |conn| conn.torque_load_additional_types }
+            end
+          end
         end
       end
     end

data/lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -5,29 +5,25 @@ module Torque
     module Reflection
       module AbstractReflection
         AREL_ATTR = ::Arel::Attributes::Attribute
-
-        ARR_NO_CAST = 'bigint'
-        ARR_CAST = 'bigint[]'
+        AREL_NODE = ::Arel::Nodes::Node
 
         # Check if the foreign key actually exists
         def connected_through_array?
           false
         end
 
-        # Fix where the join_scope method is the one now responsible for
-        # building the join condition
+        # Connection through an array-like attribute is more complex then just
+        # a simple eq. This needs to go through the channel that handles larger
+        # situations
         def join_scope(table, foreign_table, foreign_klass)
           return super unless connected_through_array?
 
-          predicate_builder = predicate_builder(table)
+          table_md = ActiveRecord::TableMetadata.new(klass, table)
+          predicate_builder = klass.predicate_builder.with(table_md)
           scope_chain_items = join_scopes(table, predicate_builder)
           klass_scope       = klass_join_scope(table, predicate_builder)
 
           klass_scope.where!(build_id_constraint_between(table, foreign_table))
-          klass_scope.where!(type => foreign_klass.polymorphic_name) if type
-          klass_scope.where!(klass.send(:type_condition, table)) \
-            if klass.finder_needs_type_condition?
-
           scope_chain_items.inject(klass_scope, &:merge!)
         end
 
@@ -40,43 +36,15 @@ module Torque
           result
         end
 
-        # Build the id constraint checking if both types are perfect matching.
-        # The klass attribute (left side) will always be a column attribute
-        def build_id_constraint(klass_attr, source_attr)
-          return klass_attr.eq(source_attr) unless connected_through_array?
-
-          # Klass and key are associated with the reflection Class
-          klass_type = klass.columns_hash[join_keys.key.to_s]
-
-          # Apply an ANY operation which checks if the single value on the left
-          # side exists in the array on the right side
-          if source_attr.is_a?(AREL_ATTR)
-            any_value = [klass_attr, source_attr]
-            any_value.reverse! if klass_type.try(:array?)
-            return any_value.shift.eq(::Arel::Nodes::NamedFunction.new('ANY', any_value))
-          end
-
-          # If the left side is not an array, just use the IN condition
-          return klass_attr.in(source_attr) unless klass_type.try(:array)
-
-          # Build the overlap condition (array && array) ensuring that the right
-          # side has the same type as the left side
-          source_attr = ::Arel::Nodes.build_quoted(Array.wrap(source_attr))
-          klass_attr.overlaps(source_attr.cast(klass_type.sql_type_metadata.sql_type))
-        end
-
-        # TODO: Deprecate this method
-        def join_keys
-          OpenStruct.new(key: join_primary_key, foreign_key: join_foreign_key)
-        end
-
         private
 
+          # This one is a lot simpler, now that we have a predicate builder that
+          # knows exactly what to do with 2 array-like attributes
           def build_id_constraint_between(table, foreign_table)
-            klass_attr  = table[join_primary_key]
-            source_attr = foreign_table[join_foreign_key]
-
-            build_id_constraint(klass_attr, source_attr)
+            PredicateBuilder::ArelAttributeHandler.call(
+              table[join_primary_key],
+              foreign_table[join_foreign_key],
+            )
           end
       end
 

data/lib/torque/postgresql/reflection/belongs_to_many_reflection.rb

@@ -44,6 +44,10 @@ module Torque
           foreign_key
         end
 
+        def array_attribute
+          active_record.arel_table[foreign_key]
+        end
+
         private
 
           def derive_primary_key

data/lib/torque/postgresql/reflection/has_many_reflection.rb

@@ -7,6 +7,10 @@ module Torque
         def connected_through_array?
           options[:array]
         end
+
+        def array_attribute
+          klass.arel_table[foreign_key]
+        end
       end
 
       ::ActiveRecord::Reflection::HasManyReflection.include(HasManyReflection)

data/lib/torque/postgresql/reflection/runtime_reflection.rb

@@ -5,7 +5,7 @@ module Torque
     module Reflection
       module RuntimeReflection
         delegate :klass, :active_record, :connected_through_array?, :macro, :name,
-          :build_id_constraint, to: :@reflection
+          :array_attribute, to: :@reflection
       end
 
       ::ActiveRecord::Reflection::RuntimeReflection.include(RuntimeReflection)

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

@@ -6,9 +6,14 @@ module Torque
       module AuxiliaryStatement
 
         # :nodoc:
-        def auxiliary_statements_values; get_value(:auxiliary_statements); end
+        def auxiliary_statements_values
+          @values.fetch(:auxiliary_statements, FROZEN_EMPTY_ARRAY)
+        end
         # :nodoc:
-        def auxiliary_statements_values=(value); set_value(:auxiliary_statements, value); end
+        def auxiliary_statements_values=(value)
+          assert_modifiable!
+          @values[:auxiliary_statements] = value
+        end
 
         # Set use of an auxiliary statement
         def with(*args, **settings)

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Relation
+      module Buckets
+
+        # :nodoc:
+        def buckets_value
+          @values.fetch(:buckets, nil)
+        end
+        # :nodoc:
+        def buckets_value=(value)
+          assert_modifiable!
+          @values[:buckets] = value
+        end
+
+        # Specifies how to bucket records. It works for both the calculations
+        # or just putting records into groups. For example:
+        #
+        #   User.buckets(:created_at, [1.year.ago, 1.month.ago, 1.week.ago])
+        #   # Returns all users grouped by created_at in the given time ranges
+        #
+        #   User.buckets(:age, 0..100, step: 10).count
+        #   # Counts all users grouped by age buckets of 10 years
+        def buckets(*value, **xargs)
+          spawn.buckets!(*value, **xargs)
+        end
+
+        # Like #buckets, but modifies relation in place.
+        def buckets!(attribute, values, count: nil, cast: nil, as: nil)
+          raise ArgumentError, <<~MSG.squish if !values.is_a?(Array) && !values.is_a?(Range)
+            Buckets must be an array or a range.
+          MSG
+
+          count ||= 1 if values.is_a?(Range)
+          attribute = arel_table[attribute] unless ::Arel.arel_node?(attribute)
+          self.buckets_value = [attribute, values, count, cast, as]
+          self
+        end
+
+        # When performing calculations with buckets, this method add a grouping
+        # clause to the query by the bucket values, and then adjust the keys
+        # to match provided values
+        def calculate(*)
+          return super if buckets_value.blank?
+
+          raise ArgumentError, <<~MSG.squish if group_values.present?
+            Cannot calculate with buckets when there are already group values.
+          MSG
+
+          keys = buckets_keys
+          self.group_values = [FN.group_by(build_buckets_node, :bucket)]
+          super.transform_keys { |key| keys[key - 1] }
+        end
+
+        module Initializer
+          # Hook into the output of records to make sure we group by the buckets
+          def records
+            return super if buckets_value.blank?
+
+            keys = buckets_keys
+            col = buckets_column
+            super.group_by do |record|
+              val = (record[col] || 0) - 1
+              keys[val] if val >= 0 && val < keys.size
+            end
+          end
+        end
+
+        private
+
+          # Hook arel build to add the column
+          def build_arel(*)
+            return super if buckets_value.blank? || select_values.present?
+
+            self.select_extra_values += [build_buckets_node.as(buckets_column)]
+            super
+          end
+
+          # Build the Arel node for the buckets function
+          def build_buckets_node
+            attribute, values, count, cast, * = buckets_value
+
+            if values.is_a?(Range)
+              FN.width_bucket(
+                attribute,
+                FN.bind_type(values.begin, name: 'bucket_start', cast: 'numeric'),
+                FN.bind_type(values.end, name: 'bucket_end', cast: 'numeric'),
+                FN.bind_type(count, name: 'bucket_count', cast: 'integer'),
+              )
+            else
+              FN.width_bucket(attribute, ::Arel.array(values, cast: cast))
+            end
+          end
+
+          # Returns the column used for buckets, if any
+          def buckets_column
+            buckets_value.last&.to_s || 'bucket'
+          end
+
+          # Transform a range into the proper keys for buckets
+          def buckets_keys
+            keys = buckets_value.second
+            return keys unless keys.is_a?(Range)
+
+            left = nil
+            step = buckets_value.third
+            step = (keys.end - keys.begin).fdiv(step)
+            step = step.to_i if step.to_i == step
+            keys.step(step).each_with_object([]) do |right, result|
+              next left = right if left.nil?
+
+              start, left = left, right
+              result << Range.new(start, left, true)
+            end
+          end
+
+      end
+
+      Initializer.include(Buckets::Initializer)
+    end
+  end
+end

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

@@ -6,9 +6,14 @@ module Torque
       module DistinctOn
 
         # :nodoc:
-        def distinct_on_values; get_value(:distinct_on); end
+        def distinct_on_values
+          @values.fetch(:distinct_on, FROZEN_EMPTY_ARRAY)
+        end
         # :nodoc:
-        def distinct_on_values=(value); set_value(:distinct_on, value); end
+        def distinct_on_values=(value)
+          assert_modifiable!
+          @values[:distinct_on] = value
+        end
 
         # Specifies whether the records should be unique or not by a given set
         # of fields. For example:

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

@@ -5,17 +5,25 @@ module Torque
     module Relation
       module Inheritance
 
-        # REGCLASS = ::Arel.sql('tableoid').cast('regclass')
-
         # :nodoc:
-        def cast_records_value; get_value(:cast_records); end
+        def cast_records_values
+          @values.fetch(:cast_records, FROZEN_EMPTY_ARRAY)
+        end
         # :nodoc:
-        def cast_records_value=(value); set_value(:cast_records, value); end
+        def cast_records_values=(value)
+          assert_modifiable!
+          @values[:cast_records] = value
+        end
 
         # :nodoc:
-        def itself_only_value; get_value(:itself_only); end
+        def itself_only_value
+          @values.fetch(:itself_only, nil)
+        end
         # :nodoc:
-        def itself_only_value=(value); set_value(:itself_only, value); end
+        def itself_only_value=(value)
+          assert_modifiable!
+          @values[:itself_only] = value
+        end
 
         delegate :quote_table_name, :quote_column_name, to: :connection
 
@@ -46,9 +54,9 @@ module Torque
 
         # Like #cast_records, but modifies relation in place
         def cast_records!(*types, **options)
-          where!(regclass.cast(:varchar).in(types.map(&:table_name))) if options[:filter]
+          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_value = (types.present? ? types : model.casted_dependents.values)
+          self.cast_records_values = (types.present? ? types : model.casted_dependents.values)
           self
         end
 
@@ -64,23 +72,22 @@ module Torque
 
           # Build all necessary data for inheritances
           def build_inheritances(arel)
-            return unless self.cast_records_value.present?
+            return if self.cast_records_values.empty?
 
             mergeable = inheritance_mergeable_attributes
 
-            columns = build_inheritances_joins(arel, self.cast_records_value)
+            columns = build_inheritances_joins(arel, self.cast_records_values)
             columns = columns.map do |column, arel_tables|
               next arel_tables.first[column] if arel_tables.size == 1
 
               if mergeable.include?(column)
-                list = arel_tables.each_with_object(column).map(&:[])
-                ::Arel::Nodes::NamedFunction.new('COALESCE', list).as(column)
+                FN.coalesce(*arel_tables.each_with_object(column).map(&:[])).as(column)
               else
                 arel_tables.map { |table| table[column].as("#{table.left.name}__#{column}") }
               end
             end
 
-            columns.push(build_auto_caster_marker(arel, self.cast_records_value))
+            columns.push(build_auto_caster_marker(arel, self.cast_records_values))
             self.select_extra_values += columns.flatten if columns.any?
           end
 
@@ -105,12 +112,12 @@ module Torque
           end
 
           def build_auto_caster_marker(arel, types)
-            attribute = regclass.cast(:varchar).in(types.map(&:table_name))
+            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'].cast(:regclass)
+            arel_table['tableoid'].pg_cast(:regclass)
           end
 
       end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Relation
+      module JoinSeries
+
+        # Create the proper arel join
+        class << self
+          def build(relation, range, with: nil, as: :series, step: nil, time_zone: nil, mode: :inner, &block)
+            validate_build!(range, step)
+
+            args = [bind_value(range.begin), bind_value(range.end)]
+            args << bind_value(step) if step
+            args << bind_value(time_zone) if time_zone
+
+            result = Arel::Nodes::Ref.new(as.to_s)
+            func = FN.generate_series(*args).as(as.to_s)
+            condition = build_join_on(result, relation, with, &block)
+            arel_join(mode).new(func, func.create_on(condition))
+          end
+
+          private
+
+            # Make sure we have a viable range
+            def validate_build!(range, step)
+              raise ArgumentError, <<~MSG.squish unless range.is_a?(Range)
+                Value must be a Range.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if range.begin.nil?
+                Beginless Ranges are not supported.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if range.end.nil?
+                Endless Ranges are not supported.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if !range.begin.is_a?(Numeric) && step.nil?
+                missing keyword: :step
+              MSG
+            end
+
+            # Creates the proper bind value
+            def bind_value(value)
+              case value
+              when Integer
+                FN.bind_type(value, :integer, name: 'series', cast: 'integer')
+              when Float
+                FN.bind_type(value, :float, name: 'series', cast: 'numeric')
+              when String
+                FN.bind_type(value, :string, name: 'series', cast: 'text')
+              when ActiveSupport::TimeWithZone
+                FN.bind_type(value, :time, name: 'series', cast: 'timestamptz')
+              when Time
+                FN.bind_type(value, :time, name: 'series', cast: 'timestamp')
+              when DateTime
+                FN.bind_type(value, :datetime, name: 'series', cast: 'timestamp')
+              when ActiveSupport::Duration
+                type = Adapter::OID::Interval.new
+                FN.bind_type(value, type, name: 'series', cast: 'interval')
+              when Date then bind_value(value.to_time(:utc))
+              when ::Arel::Attributes::Attribute then value
+              else
+                raise ArgumentError, "Unsupported value type: #{value.class}"
+              end
+            end
+
+            # Get the class of the join on arel
+            def arel_join(mode)
+              case mode.to_sym
+              when :inner then ::Arel::Nodes::InnerJoin
+              when :left  then ::Arel::Nodes::OuterJoin
+              when :right then ::Arel::Nodes::RightOuterJoin
+              when :full  then ::Arel::Nodes::FullOuterJoin
+              else
+                raise ArgumentError, <<-MSG.squish
+                  The '#{mode}' is not implemented as a join type.
+                MSG
+              end
+            end
+
+            # Build the join on clause
+            def build_join_on(result, relation, with)
+              raise ArgumentError, <<~MSG.squish if with.nil? && !block_given?
+                missing keyword: :with
+              MSG
+
+              return yield(result, relation.arel_table) if block_given?
+
+              result.eq(with.is_a?(Symbol) ? relation.arel_table[with.to_s] : with)
+            end
+        end
+
+        # Creates a new join based on PG +generate_series()+ function. It is
+        # based on ranges, supports numbers and dates (as per PG documentation),
+        # custom stepping, time zones, and more. This simply coordinates the
+        # initialization of the the proper join
+        def join_series(range, **xargs, &block)
+          spawn.join_series!(range, **xargs, &block)
+        end
+
+        # Like #join_series, but modifies relation in place.
+        def join_series!(range, **xargs, &block)
+          self.joins_values |= [JoinSeries.build(self, range, **xargs, &block)]
+          self
+        end
+
+      end
+    end
+  end
+end