torque-postgresql 3.4.1 → 4.0.0.rc1

data/lib/torque/postgresql/inheritance.rb

@@ -20,15 +20,14 @@ module Torque
         klass.find(self.id)
       end
 
-      module ClassMethods
+      class_methods do
         delegate :_auto_cast_attribute, :_record_class_attribute, to: ActiveRecord::Relation
 
         # Get a full list of all attributes from a model and all its dependents
         def inheritance_merged_attributes
           @inheritance_merged_attributes ||= begin
-            list = attribute_names
-            list += casted_dependents.values.map(&:attribute_names)
-            list.flatten.uniq.freeze
+            children = casted_dependents.values.flat_map(&:attribute_names)
+            attribute_names.to_set.merge(children).to_a.freeze
           end
         end
 
@@ -45,11 +44,11 @@ module Torque
               end
             end
 
-            result = types.select do
-              |_, types| types.each_with_object(types.shift).all?(&:==)
-            end.keys + attribute_names
+            result = types.filter_map do |attribute, types|
+              attribute if types.each_with_object(types.shift).all?(&:==)
+            end
 
-            result.freeze
+            (attribute_names + result).freeze
           end
         end
 
@@ -111,22 +110,19 @@ module Torque
         # For all main purposes, physical inherited classes should have
         # base_class as their own
         def base_class
-          return super unless physically_inherited?
-          self
+          physically_inherited? ? self : super
         end
 
         # Primary key is one exception when getting information about the class,
         # it must returns the superclass PK
         def primary_key
-          return super unless physically_inherited?
-          superclass.primary_key
+          physically_inherited? ? superclass.primary_key : super
         end
 
         # Add an additional check to return the name of the table even when the
         # class is inherited, but only if it is a physical inheritance
         def compute_table_name
-          return super unless physically_inherited?
-          decorated_table_name
+          physically_inherited? ? decorated_table_name : super
         end
 
         # Raises an error message saying that the giver record class was not
@@ -142,37 +138,57 @@ module Torque
 
         private
 
-          def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+          # If the class is physically inherited, the klass needs to be properly
+          # changed before moving forward
+          def instantiate_instance_of(klass, attributes, types = {}, &block)
             return super unless klass.physically_inheritances?
 
-            auto_cast = _auto_cast_attribute.to_s
-            record_class = _record_class_attribute.to_s
-            return super unless attributes.key?(record_class) &&
-              attributes.delete(auto_cast) && attributes[record_class] != table_name
-
-            klass = casted_dependents[attributes[record_class]]
-            raise_unable_to_cast(attributes[record_class]) if klass.nil?
-            filter_attributes_for_cast(attributes, klass)
+            real_class = torque_discriminate_class_for_record(klass, attributes)
+            return super if real_class.nil?
 
-            super(klass, attributes, column_types, &block)
+            attributes, types = sanitize_attributes(real_class, attributes, types)
+            super(real_class, attributes, types, &block)
           end
 
-          # Filter the record attributes to be loaded to not included those from
-          # another inherited dependent
-          def filter_attributes_for_cast(record, klass)
-            new_record = record.slice(*klass.attribute_names)
-            table = new_record[_record_class_attribute.to_s] = klass.table_name
-
-            # Recover aliased attributes
-            (klass.attribute_names - inheritance_mergeable_attributes).each do |attribute|
-              new_record[attribute] = record["#{table}__#{attribute}"]
+          # Unwrap the attributes and column types from the given class when
+          # there are unmergeable attributes
+          def sanitize_attributes(real_class, attributes, types)
+            skip = (inheritance_merged_attributes - real_class.attribute_names).to_set
+            skip.merge(real_class.attribute_names - inheritance_mergeable_attributes)
+            return [attributes, types] if skip.empty?
+
+            dropped = 0
+            new_types = {}
+
+            row = attributes.instance_variable_get(:@row).dup
+            indexes = attributes.instance_variable_get(:@column_indexes).dup
+            indexes = indexes.each_with_object({}) do |(column, index), new_indexes|
+              attribute, prefix = column.split('__', 2).reverse
+              current_index = index - dropped
+
+              if prefix != table_name && skip.include?(attribute)
+                row.delete_at(current_index)
+                dropped += 1
+              else
+                new_types.merge!(types.slice(attribute))
+                new_types[current_index] = types[index]
+                new_indexes[attribute] = current_index
+              end
             end
 
-            # Add any additional columns and replace the record with the new record data
-            new_record.merge!(record.slice(*(record.keys - inheritance_merged_attributes)))
-            record.replace(new_record)
+            [ActiveRecord::Result::IndexedRow.new(indexes, row), new_types]
           end
 
+          # Get the real class when handling physical inheritances and casting
+          # the record when existing properly is present
+          def torque_discriminate_class_for_record(klass, record)
+            return if record[_auto_cast_attribute.to_s] == false
+
+            embedded_type = record[_record_class_attribute.to_s]
+            return if embedded_type.blank? || embedded_type == table_name
+
+            casted_dependents[embedded_type] || raise_unable_to_cast(embedded_type)
+          end
       end
     end
 

data/lib/torque/postgresql/predicate_builder/arel_attribute_handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class ArelAttributeHandler
+        # Shortcut
+        def self.call(*args)
+          new.call(*args)
+        end
+
+        def initialize(*)
+          # There is no need to use or save the predicate builder here
+        end
+
+        def call(attribute, value)
+          case
+          when array_typed?(attribute) && array_typed?(value) then attribute.overlaps(value)
+          when array_typed?(attribute) then value.eq(FN.any(attribute))
+          when array_typed?(value) then attribute.eq(FN.any(value))
+          else attribute.eq(value)
+          end
+        end
+
+        private
+
+          def array_typed?(attribute)
+            attribute.able_to_type_cast? && attribute.type_caster.is_a?(ARRAY_OID)
+          end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/predicate_builder/array_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      module ArrayHandler
+        def call(attribute, value)
+          return super unless array_attribute?(attribute) &&
+            PostgreSQL.config.predicate_builder.handle_array_attributes
+
+          call_for_array(attribute, value)
+        end
+
+        def call_for_array(attribute, value)
+          if !value.is_a?(::Array)
+            call_with_value(attribute, value)
+          elsif value.any?
+            call_with_array(attribute, value)
+          else
+            call_with_empty(attribute)
+          end
+        end
+
+        private
+
+          def call_with_value(attribute, value)
+            FN.infix(:"=", FN.bind_with(attribute, value), FN.any(attribute))
+          end
+
+          def call_with_array(attribute, value)
+            attribute.overlaps(FN.bind_with(attribute, value))
+          end
+
+          def call_with_empty(attribute)
+            FN.cardinality(attribute).eq(0)
+          end
+
+          def array_attribute?(attribute)
+            attribute.type_caster.is_a?(ARRAY_OID)
+          end
+      end
+
+      ::ActiveRecord::PredicateBuilder::ArrayHandler.prepend(ArrayHandler)
+      ::ActiveRecord::PredicateBuilder::BasicObjectHandler.prepend(ArrayHandler)
+    end
+  end
+end

data/lib/torque/postgresql/predicate_builder/enumerator_lazy_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class EnumeratorLazyHandler < ::ActiveRecord::PredicateBuilder::ArrayHandler
+        Timeout = Class.new(::Timeout::Error)
+
+        def call(attribute, value)
+          with_timeout do
+            super(attribute, limit.nil? ? value.force : value.first(limit))
+          end
+        end
+
+        private
+
+          def with_timeout
+            return yield if timeout.nil?
+
+            begin
+              ::Timeout.timeout(timeout) { yield }
+            rescue ::Timeout::Error
+              raise Timeout, "Lazy predicate builder timed out after #{timeout} seconds"
+            end
+          end
+
+          def timeout
+            PostgreSQL.config.predicate_builder.lazy_timeout
+          end
+
+          def limit
+            PostgreSQL.config.predicate_builder.lazy_limit
+          end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/predicate_builder/regexp_handler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      class RegexpHandler
+        def initialize(predicate_builder)
+          @predicate_builder = predicate_builder
+        end
+
+        def call(attribute, value)
+          operator = value.casefold? ? :"~*" : :"~"
+          FN.infix(operator, attribute, FN.bind_with(attribute, value.source))
+        end
+
+        private
+          attr_reader :predicate_builder
+      end
+    end
+  end
+end

data/lib/torque/postgresql/predicate_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'predicate_builder/array_handler'
+
+require_relative 'predicate_builder/regexp_handler'
+require_relative 'predicate_builder/arel_attribute_handler'
+require_relative 'predicate_builder/enumerator_lazy_handler'
+
+module Torque
+  module PostgreSQL
+    module PredicateBuilder
+      ARRAY_OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+
+      def initialize(*)
+        super
+
+        handlers = Array.wrap(PostgreSQL.config.predicate_builder.enabled).inquiry
+
+        if handlers.regexp?
+          register_handler(Regexp, RegexpHandler.new(self))
+        end
+
+        if handlers.enumerator_lazy?
+          register_handler(Enumerator::Lazy, EnumeratorLazyHandler.new(self))
+        end
+
+        if handlers.arel_attribute?
+          register_handler(::Arel::Attributes::Attribute, ArelAttributeHandler.new(self))
+        end
+      end
+    end
+
+    ::ActiveRecord::PredicateBuilder.prepend(PredicateBuilder)
+  end
+end

data/lib/torque/postgresql/railtie.rb

@@ -4,41 +4,123 @@ 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
+
+            ## 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.constantize.const_set(name, PostgreSQL::FN)
+            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/inheritance.rb

@@ -5,8 +5,6 @@ module Torque
     module Relation
       module Inheritance
 
-        # REGCLASS = ::Arel.sql('tableoid').cast('regclass')
-
         # :nodoc:
         def cast_records_value; get_value(:cast_records); end
         # :nodoc:
@@ -46,7 +44,7 @@ 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
@@ -73,8 +71,7 @@ module Torque
               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
@@ -105,12 +102,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