torque-postgresql 3.4.1 → 4.0.0

data/lib/torque/postgresql/attributes.rb

@@ -1,6 +1,2 @@
 require_relative 'attributes/lazy'
 require_relative 'attributes/builder'
-
-require_relative 'attributes/enum'
-require_relative 'attributes/enum_set'
-require_relative 'attributes/period'

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

@@ -136,10 +136,10 @@ module Torque
 
               col = table[name]
               base.select_extra_values += [col.as(as)] unless as.nil?
-              parts = [col, source.cast(:varchar)]
+              parts = [col, source.pg_cast(:varchar)]
 
-              columns << ::Arel.array([source]).cast(:varchar, true).as(name)
-              sub_columns << ::Arel::Nodes::NamedFunction.new('array_append', parts).as(name)
+              columns << ::Arel.array([source]).pg_cast(:varchar, true).as(name)
+              sub_columns << FN.array_append(*parts).as(name)
             end
           end
 

data/lib/torque/postgresql/base.rb

@@ -16,11 +16,13 @@ module Torque
         class_attribute :schema, instance_writer: false
       end
 
-      module ClassMethods
-        delegate :distinct_on, :with, :itself_only, :cast_records, to: :all
+      class_methods do
+        delegate :distinct_on, :with, :itself_only, :cast_records, :join_series,
+          :buckets, to: :all
 
         # Make sure that table name is an instance of TableName class
         def reset_table_name
+          return super unless PostgreSQL.config.schemas.enabled
           self.table_name = TableName.new(self, super)
         end
 
@@ -41,7 +43,7 @@ module Torque
             next klass.table_name unless klass.physically_inheritances?
 
             query = klass.unscoped.where(subclass.primary_key => id)
-            query.pluck(klass.arel_table['tableoid'].cast('regclass')).first
+            query.pluck(klass.arel_table['tableoid'].pg_cast('regclass')).first
           end
         end
 
@@ -200,14 +202,6 @@ module Torque
           ::ActiveRecord::Reflection.add_reflection(self, name, reflection)
         end
 
-        # Allow extra keyword arguments to be sent to +InsertAll+
-        unless Torque::PostgreSQL::AR720
-          def upsert_all(attributes, **xargs)
-            xargs = xargs.reverse_merge(on_duplicate: :update)
-            ::ActiveRecord::InsertAll.new(self, attributes, **xargs).execute
-          end
-        end
-
         protected
 
           # Allow optional select attributes to be loaded manually when they are

data/lib/torque/postgresql/collector.rb

@@ -4,7 +4,7 @@ module Torque
   module PostgreSQL
     module Collector
 
-      # This classe helps to collect data in different ways. Used to configure
+      # This class helps to collect data in different ways. Used to configure
       # auxiliary statements
       def self.new(*args)
         klass = Class.new

data/lib/torque/postgresql/config.rb

@@ -4,10 +4,6 @@ module Torque
   module PostgreSQL
     include ActiveSupport::Configurable
 
-    # Stores a version check for compatibility purposes
-    AR710 = (ActiveRecord.gem_version >= Gem::Version.new('7.1.0'))
-    AR720 = (ActiveRecord.gem_version >= Gem::Version.new('7.2.0'))
-
     # Use the same logger as the Active Record one
     def self.logger
       ActiveRecord::Base.logger
@@ -26,6 +22,12 @@ module Torque
     # same configuration is set to true
     config.eager_load = false
 
+    # Add support for joining any query/association with a generated series
+    config.join_series = true
+
+    # Add support for querying and calculating histogram buckets
+    config.buckets = true
+
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)
@@ -41,11 +43,19 @@ module Torque
       # default. False means that no validation will be performed
       assoc.belongs_to_many_required_by_default = false
 
+      # Although +belongs_to_many+ does not need a custom handler when joining
+      # the last chain scope, this can allow devs to pick which way they prefer:
+      # Rails default, or ANY with a single bind to improve prepared statements
+      # assoc.optimize_for_binds = false TODO: Add support
+
     end
 
     # Configure multiple schemas
     config.nested(:schemas) do |schemas|
 
+      # Enables schemas handler by this gem, not Rails's own implementation
+      schemas.enabled = true
+
       # Defines a list of LIKE-based schemas to not consider for a multiple
       # schema database
       schemas.blacklist = %w[information_schema pg_%]
@@ -59,6 +69,10 @@ module Torque
     # Configure auxiliary statement features
     config.nested(:auxiliary_statement) do |cte|
 
+      # Enables auxiliary statements handler by this gem, not Rails's own
+      # implementation
+      cte.enabled = true
+
       # Define the key that is used on auxiliary statements to send extra
       # arguments to format string or send on a proc
       cte.send_arguments_key = :args
@@ -76,6 +90,9 @@ module Torque
     # Configure ENUM features
     config.nested(:enum) do |enum|
 
+      # Enables enum handler by this gem, not Rails's own implementation
+      enum.enabled = true
+
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based enum features
       enum.base_method = :torque_enum
@@ -93,7 +110,7 @@ module Torque
       enum.raise_conflicting = false
 
       # Specify the namespace of each enum type of value
-      enum.namespace = ::Object.const_set('Enum', Module.new)
+      enum.namespace = nil
 
       # Specify the scopes for I18n translations
       enum.i18n_scopes = [
@@ -117,6 +134,9 @@ module Torque
     # Configure geometry data types
     config.nested(:geometry) do |geometry|
 
+      # Enables geometry handler by this gem, not Rails's own implementation
+      geometry.enabled = true
+
       # Define the class that will be handling Point data types after decoding
       # it. Any class provided here must respond to 'x', and 'y'
       geometry.point_class = ActiveRecord::Point
@@ -162,6 +182,9 @@ module Torque
     # Configure period features
     config.nested(:period) do |period|
 
+      # Enables period handler by this gem
+      period.enabled = true
+
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based period features
       period.base_method = :period_for
@@ -228,5 +251,106 @@ module Torque
       }
 
     end
+
+    # Configure period features
+    config.nested(:interval) do |interval|
+
+      # Enables interval handler by this gem, not Rails's own implementation
+      interval.enabled = true
+
+    end
+
+    # Configure arel additional features
+    config.nested(:arel) do |arel|
+
+      # When provided, the initializer will expose the Arel function helper on
+      # the given module
+      config.expose_function_helper_on = nil
+
+      # List of Arel INFIX operators that will be made available for using as
+      # methods on Arel::Nodes::Node and Arel::Attribute
+      arel.infix_operators = {
+        'contained_by'        => '<@',
+        'has_key'             => '?',
+        'has_all_keys'        => '?&',
+        'has_any_keys'        => '?|',
+        'strictly_left'       => '<<',
+        'strictly_right'      => '>>',
+        'doesnt_right_extend' => '&<',
+        'doesnt_left_extend'  => '&>',
+        'adjacent_to'         => '-|-',
+      }
+
+    end
+
+    # Configure full text search features
+    config.nested(:full_text_search) do |fts|
+
+      # Enables full text search handler by this gem
+      fts.enabled = true
+
+      # The name of the method to be used on any ActiveRecord::Base to
+      # initialize model-based full text search features
+      fts.base_method = :torque_search_for
+
+      # Defines the default language when generating search vector columns
+      fts.default_language = 'english'
+
+      # Defines the default mode to be used when generating full text search
+      # queries. It can be one of the following:
+      #   - :default (to_tsquery)
+      #   - :phrase (phraseto_tsquery)
+      #   - :plain (plainto_tsquery)
+      #   - :web (websearch_to_tsquery)
+      fts.default_mode = :phrase
+
+      # Defines the default index type to be used when creating search vector.
+      # It still requires that the column requests an index
+      fts.default_index_type = :gin
+
+    end
+
+    # Configure predicate builder additional features
+    config.nested(:predicate_builder) do |builder|
+
+      # List which handlers are enabled by default
+      builder.enabled = %i[regexp arel_attribute enumerator_lazy]
+
+      # When active, values provided to array attributes will be handled more
+      # friendly. It will use the +ANY+ operator on a equality check and
+      # overlaps when the given value is an array
+      builder.handle_array_attributes = false
+
+      # Make sure that the predicate builder will not spend more than 20ms
+      # trying to produce the underlying array
+      builder.lazy_timeout = 0.02
+
+      # Since lazy array is uncommon, it is better to limit the number of
+      # entries we try to pull so we don't cause a timeout or a long wait
+      # iteration
+      builder.lazy_limit = 2_000
+
+    end
+
+    # Configure versioned commands features
+    config.nested(:versioned_commands) do |vs|
+
+      # This is a feature that developers must explicitly opt-in. It is designed
+      # in a way that prevents a large impact on Rails' original migrations
+      # behavior. But, it is still a feature that everyone may not need, and
+      # some may complain about the additional schema table, which also uses
+      # inheritance
+      vs.enabled = false
+
+      # Define the list of commands that are going to be versioned by this
+      # method
+      vs.types = %i[function type view]
+
+      # The name of the table that will inherit from +schema_migrations+ and
+      # store the list of versioned commands that have been executed
+      vs.table_name = 'schema_versioned_commands'
+
+    end
+
   end
 end

data/lib/torque/postgresql/function.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    # Simplified module for creating arel functions. This is used internally
+    # but can also be made available to other devs on their own projects
+    module Function
+      class << self
+
+        # A facilitator to create a bind param that is fully compatible with
+        # Arel and ActiveRecord
+        def bind(*args)
+          attr = ::ActiveRecord::Relation::QueryAttribute.new(*args)
+          ::Arel::Nodes::BindParam.new(attr)
+        end
+
+        # Just a shortcut to create a bind param for a model attribute and a
+        # value for it
+        def bind_for(model, attribute, value)
+          bind(attribute, value, model.attribute_types[attribute])
+        end
+
+        # Another shortcut, when we already have the arel attribute at hand
+        def bind_with(arel_attribute, value)
+          bind(arel_attribute.name, value, arel_attribute.type_caster)
+        end
+
+        # A facilitator to create a bind param with a specific type
+        def bind_type(value, type = nil, name: 'value', cast: nil)
+          type ||= ruby_type_to_model_type(value)
+          type = ActiveModel::Type.lookup(type) if type.is_a?(Symbol)
+          result = bind(name, value, type)
+          cast ? result.pg_cast(cast) : result
+        end
+
+        # A facilitator to create an infix operation
+        def infix(op, left, right)
+          ::Arel::Nodes::InfixOperation.new(op, left, right)
+        end
+
+        # A facilitator to use several Infix operators to concatenate all the
+        # provided arguments. Arguments won't be sanitized, as other methods
+        # under this module
+        def concat(*args)
+          return args.first if args.one?
+          args.reduce { |left, right| infix(:"||", left, right) }
+        end
+
+        # A simple helper to trick Rails into producing the right SQL for
+        # grouping operations
+        def group_by(arel, name)
+          Arel::Nodes::Ref.new(name.to_s, arel)
+        end
+
+        # As of now, this indicates that it supports any direct calls, since
+        # the idea is to simply map to an Arel function with the same name,
+        # without checking if it actually exists
+        def respond_to_missing?(*)
+          true
+        end
+
+        # This method is used to catch any method calls that are not defined
+        # in this module. It will simply return an Arel function with the same
+        # name as the method called, passing all arguments to it, without
+        # any sanitization
+        def method_missing(name, *args, &block)
+          ::Arel::Nodes::NamedFunction.new(name.to_s.upcase, args)
+        end
+
+        private
+
+          def ruby_type_to_model_type(value)
+            case value
+            when Integer then :integer
+            when Float then :float
+            when String then :string
+            when Time, ActiveSupport::TimeWithZone then :time
+            when TrueClass, FalseClass then :boolean
+            when DateTime then :datetime
+            when Date then :date
+            when BigDecimal then :decimal
+            when ActiveSupport::Duration
+              Adapter::OID::Interval.new
+            else
+              raise ArgumentError, "Cannot infer type from value: #{value.inspect}."
+            end
+          end
+
+      end
+    end
+
+    FN = Function
+  end
+end

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