torque-postgresql 3.4.1 → 4.0.0.rc1

data/lib/torque/postgresql/attributes/builder/period.rb

@@ -4,13 +4,11 @@ module Torque
   module PostgreSQL
     module Attributes
       module Builder
-        # TODO: Allow documenting by building the methods outside and importing
-        # only the raw string
         class Period
           DIRECT_ACCESS_REGEX = /_?%s_?/
           SUPPORTED_TYPES = %i[daterange tsrange tstzrange].freeze
           CURRENT_GETTERS = {
-            daterange: 'Date.today',
+            daterange: 'Date.current',
             tsrange:   'Time.zone.now',
             tstzrange: 'Time.zone.now',
           }.freeze
@@ -21,6 +19,8 @@ module Torque
             tstzrange: :timestamp,
           }.freeze
 
+          FN = '::Torque::PostgreSQL::FN'
+
           attr_accessor :klass, :attribute, :options, :type, :default, :current_getter,
             :type_caster, :threshold, :dynamic_threshold, :klass_module, :instance_module
 
@@ -208,11 +208,11 @@ module Torque
             end
 
             def arel_default_sql
-              @arel_default_sql ||= arel_sql_quote(@default.inspect)
+              @arel_default_sql ||= arel_sql_bind(@default.inspect)
             end
 
-            def arel_sql_quote(value)
-              "::Arel.sql(connection.quote(#{value}))"
+            def arel_sql_bind(value)
+              "#{FN}.bind_with(#{arel_attribute}, #{value})"
             end
 
             # Check how to provide the threshold value
@@ -223,12 +223,12 @@ module Torque
                   "arel_table['#{threshold}']"
                 when ActiveSupport::Duration
                   value = "'#{threshold.to_i} seconds'"
-                  "::Arel.sql(\"#{value}\").cast(:interval)"
+                  "::Arel.sql(\"#{value}\").pg_cast(:interval)"
                 when Numeric
                   value = threshold.to_i.to_s
                   value << type_caster.eql?(:date) ? ' days' : ' seconds'
                   value = "'#{value}'"
-                  "::Arel.sql(\"#{value}\").cast(:interval)"
+                  "::Arel.sql(\"#{value}\").pg_cast(:interval)"
                 end
               end
             end
@@ -248,7 +248,7 @@ module Torque
               return arel_start_at unless threshold.present?
               @arel_real_start_at ||= begin
                 result = +"(#{arel_start_at} - #{arel_threshold_value})"
-                result << '.cast(:date)' if  type.eql?(:daterange)
+                result << '.pg_cast(:date)' if type.eql?(:daterange)
                 result
               end
             end
@@ -258,7 +258,7 @@ module Torque
               return arel_finish_at unless threshold.present?
               @arel_real_finish_at ||= begin
                 result = +"(#{arel_finish_at} + #{arel_threshold_value})"
-                result << '.cast(:date)' if  type.eql?(:daterange)
+                result << '.pg_cast(:date)' if type.eql?(:daterange)
                 result
               end
             end
@@ -278,9 +278,9 @@ module Torque
 
             # Create an arel named function
             def arel_named_function(name, *args)
-              result = +"::Arel::Nodes::NamedFunction.new(#{name.to_s.inspect}"
-              result << ', [' << args.join(', ') << ']' if args.present?
-              result << ')'
+              result = +"#{FN}.#{name}"
+              result << '(' << args.join(', ') << ')' if args.present?
+              result
             end
 
             # Create an arel version of +nullif+ function
@@ -302,24 +302,24 @@ module Torque
             def arel_daterange(real = false)
               arel_named_function(
                 'daterange',
-                (real ? arel_real_start_at : arel_start_at) + '.cast(:date)',
-                (real ? arel_real_finish_at : arel_finish_at) + '.cast(:date)',
+                (real ? arel_real_start_at : arel_start_at) + '.pg_cast(:date)',
+                (real ? arel_real_finish_at : arel_finish_at) + '.pg_cast(:date)',
                 '::Arel.sql("\'[]\'")',
               )
             end
 
             def arel_check_condition(type)
               checker = arel_nullif(arel_real_attribute, arel_empty_value)
-              checker << ".#{type}(value.cast(#{type_caster.inspect}))"
+              checker << ".#{type}(value.pg_cast(#{type_caster.inspect}))"
               arel_coalesce(checker, arel_default_sql)
             end
 
             def arel_formatting_value(condition = nil, value = 'value', cast: nil)
               [
                 "#{value} = arel_table[#{value}] if #{value}.is_a?(Symbol)",
-                "unless #{value}.respond_to?(:cast)",
-                "  #{value} = ::Arel.sql(connection.quote(#{value}))",
-                ("  #{value} = #{value}.cast(#{cast.inspect})" if cast),
+                "unless #{value}.respond_to?(:pg_cast)",
+                "  #{value} = #{FN}.bind_with(#{arel_attribute}, #{value})",
+                ("  #{value} = #{value}.pg_cast(#{cast.inspect})" if cast),
                 'end',
                 condition,
               ].compact.join("\n")
@@ -347,14 +347,14 @@ module Torque
 
             def klass_current
               [
-                "value = #{arel_sql_quote(current_getter)}",
+                "value = #{arel_sql_bind(current_getter)}",
                 "where(#{arel_check_condition(:contains)})",
               ].join("\n")
             end
 
             def klass_not_current
               [
-                "value = #{arel_sql_quote(current_getter)}",
+                "value = #{arel_sql_bind(current_getter)}",
                 "where.not(#{arel_check_condition(:contains)})",
               ].join("\n")
             end

data/lib/torque/postgresql/attributes/builder.rb

@@ -2,6 +2,7 @@
 
 require_relative 'builder/enum'
 require_relative 'builder/period'
+require_relative 'builder/full_text_search'
 
 module Torque
   module PostgreSQL
@@ -12,20 +13,57 @@ module Torque
             return unless table_exists?
 
             args.each do |attribute|
-              begin
-                # Generate methods on self class
-                builder = builder_klass.new(self, attribute, extra.merge(options))
-                builder.conflicting?
-                builder.build
-
-                # Additional settings for the builder
-                instance_exec(builder, &block) if block.present?
-              rescue Interrupt
-                # Not able to build the attribute, maybe pending migrations
-              end
+              # Generate methods on self class
+              builder = builder_klass.new(self, attribute, extra.merge(options))
+              builder.conflicting?
+              builder.build
+
+              # Additional settings for the builder
+              instance_exec(builder, &block) if block.present?
+            rescue Interrupt
+              # Not able to build the attribute, maybe pending migrations
             end
           end
         end
+
+        def self.search_vector_options(columns:, language: nil, stored: true, **options)
+          weights = to_search_weights(columns)
+          operation = to_search_vector_operation(language, weights).to_sql
+
+          options[:index] = {
+            using: PostgreSQL.config.full_text_search.default_index_type,
+          } if options[:index] == true
+
+          options.merge(type: :tsvector, as: operation, stored: stored)
+        end
+
+        def self.to_search_weights(columns)
+          if !columns.is_a?(Hash)
+            extras = columns.size > 3 ? columns.size - 3 : 0
+            weights = %w[A B C] + (['D'] * extras)
+            columns = Array.wrap(columns).zip(weights).to_h
+          end
+
+          columns.transform_keys(&:to_s)
+        end
+
+        def self.to_search_vector_operation(language, weights)
+          language ||= PostgreSQL.config.full_text_search.default_language
+          language = ::Arel.sql(language.is_a?(Symbol) ? language.to_s : "'#{language}'")
+          simple = weights.size == 1
+
+          empty_string = ::Arel.sql("''")
+          operations = weights.map do |column, weight|
+            column = ::Arel.sql(column.to_s)
+            weight = ::Arel.sql("'#{weight}'")
+
+            op = FN.to_tsvector(language, FN.coalesce(column, empty_string))
+            op = FN.setweight(op, weight) unless simple
+            op
+          end
+
+          FN.concat(*operations)
+        end
       end
     end
   end

data/lib/torque/postgresql/attributes/enum.rb

@@ -18,7 +18,7 @@ module Torque
           # Find or create the class that will handle the value
           def lookup(name)
             const     = name.to_s.camelize
-            namespace = Torque::PostgreSQL.config.enum.namespace
+            namespace = PostgreSQL.config.enum.namespace
 
             return namespace.const_get(const) if namespace.const_defined?(const)
             namespace.const_set(const, Class.new(Enum))
@@ -27,7 +27,7 @@ module Torque
           # Provide a method on the given class to setup which enums will be
           # manually initialized
           def include_on(klass, method_name = nil)
-            method_name ||= Torque::PostgreSQL.config.enum.base_method
+            method_name ||= PostgreSQL.config.enum.base_method
             Builder.include_on(klass, method_name, Builder::Enum) do |builder|
               defined_enums[builder.attribute.to_s] = builder.subtype.klass
             end
@@ -46,7 +46,7 @@ module Torque
             end
           end
 
-          # List of valus as symbols
+          # List of values as symbols
           def keys
             values.map(&:to_sym)
           end
@@ -86,7 +86,7 @@ module Torque
             self.values.include?(value.to_s)
           end
 
-          # Build an active record scope for a given atribute agains a value
+          # Build an active record scope for a given attribute against a value
           def scope(attribute, value)
             attribute.eq(value)
           end
@@ -183,7 +183,7 @@ module Torque
               list_from = :i18n_scopes
             end
 
-            Torque::PostgreSQL.config.enum.send(list_from).map do |key|
+            PostgreSQL.config.enum.send(list_from).map do |key|
               (key % values).to_sym
             end
           end
@@ -209,7 +209,7 @@ module Torque
             end
           end
 
-          # Throw an exception for invalid valus
+          # Throw an exception for invalid values
           def raise_invalid(value)
             if value.is_a?(Numeric)
               raise EnumError, "#{value.inspect} is out of bounds of #{self.class.name}"
@@ -218,7 +218,7 @@ module Torque
             end
           end
 
-          # Throw an exception for comparasion between different enums
+          # Throw an exception for comparison between different enums
           def raise_comparison(other)
             raise EnumError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end

data/lib/torque/postgresql/attributes/enum_set.rb

@@ -18,7 +18,7 @@ module Torque
           # Find or create the class that will handle the value
           def lookup(name, enum_klass)
             const     = name.to_s.camelize + 'Set'
-            namespace = Torque::PostgreSQL.config.enum.namespace
+            namespace = PostgreSQL.config.enum.namespace
 
             return namespace.const_get(const) if namespace.const_defined?(const)
 
@@ -30,7 +30,7 @@ module Torque
           # Provide a method on the given class to setup which enum sets will be
           # manually initialized
           def include_on(klass, method_name = nil)
-            method_name ||= Torque::PostgreSQL.config.enum.set_method
+            method_name ||= PostgreSQL.config.enum.set_method
             Builder.include_on(klass, method_name, Builder::Enum, set_features: true) do |builder|
               defined_enums[builder.attribute.to_s] = builder.subtype
             end
@@ -76,14 +76,14 @@ module Torque
             end.reduce(:+)
           end
 
-          # Build an active record scope for a given atribute agains a value
+          # Build an active record scope for a given attribute against a value
           def scope(attribute, value)
-            attribute.contains(::Arel.array(value, cast: enum_source.type_name))
+            attribute.contains(FN.bind_with(attribute, value).pg_cast(type_name))
           end
 
           private
 
-            # Allows checking value existance
+            # Allows checking value existence
             def respond_to_missing?(method_name, include_private = false)
               valid?(method_name) || super
             end
@@ -226,7 +226,7 @@ module Torque
             end
           end
 
-          # Throw an exception for invalid valus
+          # Throw an exception for invalid values
           def raise_invalid(value)
             if value.is_a?(Numeric)
               raise EnumSetError, "#{value.inspect} is out of bounds of #{self.class.name}"
@@ -235,7 +235,7 @@ module Torque
             end
           end
 
-          # Throw an exception for comparasion between different enums
+          # Throw an exception for comparison between different enums
           def raise_comparison(other)
             raise EnumSetError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end

data/lib/torque/postgresql/attributes/full_text_search.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      # For now, full text search doesn't have it's own class
+      module FullTextSearch
+        class << self
+          # Provide a method on the given class to setup which full text search
+          # columns will be manually initialized
+          def include_on(klass, method_name = nil)
+            method_name ||= PostgreSQL.config.full_text_search.base_method
+            Builder.include_on(klass, method_name, Builder::FullTextSearch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/attributes/period.rb

@@ -3,13 +3,13 @@
 module Torque
   module PostgreSQL
     module Attributes
-      # For naw, period doesn't have it's own class
+      # For now, period doesn't have it's own class
       module Period
         class << self
           # Provide a method on the given class to setup which period columns
           # will be manually initialized
           def include_on(klass, method_name = nil)
-            method_name ||= Torque::PostgreSQL.config.period.base_method
+            method_name ||= PostgreSQL.config.period.base_method
             Builder.include_on(klass, method_name, Builder::Period)
           end
         end

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,12 @@ module Torque
         class_attribute :schema, instance_writer: false
       end
 
-      module ClassMethods
+      class_methods do
         delegate :distinct_on, :with, :itself_only, :cast_records, 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 +42,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 +201,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
@@ -41,11 +37,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 +63,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 +84,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 +104,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 +128,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 +176,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 +245,78 @@ 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 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
+      # efficiently. 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
+
   end
 end

data/lib/torque/postgresql/function.rb

@@ -0,0 +1,61 @@
+# 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 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
+
+        # 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
+
+      end
+    end
+
+    FN = Function
+  end
+end