torque-postgresql 3.4.1 → 4.0.0.rc1

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -4,42 +4,55 @@ module Torque
   module PostgreSQL
     module Adapter
       module SchemaStatements
-
-        TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
-
-        # Create a new schema
-        def create_schema(name, options = {})
-          drop_schema(name, options) if options[:force]
-
-          check = 'IF NOT EXISTS' if options.fetch(:check, true)
-          execute("CREATE SCHEMA #{check} #{quote_schema_name(name.to_s)}")
-        end
-
-        # Drop an existing schema
-        def drop_schema(name, options = {})
-          force = options.fetch(:force, '').upcase
-          check = 'IF EXISTS' if options.fetch(:check, true)
-          execute("DROP SCHEMA #{check} #{quote_schema_name(name.to_s)} #{force}")
-        end
-
-        # Drops a type.
+        # Drops a type
         def drop_type(name, options = {})
           force = options.fetch(:force, '').upcase
           check = 'IF EXISTS' if options.fetch(:check, true)
-          execute <<-SQL.squish
+          name = sanitize_name_with_schema(name, options)
+
+          internal_exec_query(<<-SQL.squish).tap { reload_type_map }
             DROP TYPE #{check}
-            #{quote_type_name(name, options[:schema])} #{force}
+            #{quote_type_name(name)} #{force}
           SQL
         end
 
-        # Renames a type.
+        # Renames a type
         def rename_type(type_name, new_name, options = {})
-          execute <<-SQL.squish
-            ALTER TYPE #{quote_type_name(type_name, options[:schema])}
+          type_name = sanitize_name_with_schema(type_name, options)
+          internal_exec_query(<<-SQL.squish).tap { reload_type_map }
+            ALTER TYPE #{quote_type_name(type_name)}
             RENAME TO #{Quoting::Name.new(nil, new_name.to_s).quoted}
           SQL
         end
 
+        # Creates a column that stores the underlying language of the record so
+        # that a search vector can be created dynamically based on it. It uses
+        # a `regconfig` type, so string conversions are mandatory
+        def add_search_language(table, name, options = {})
+          add_column(table, name, :regconfig, options)
+        end
+
+        # Creates a column and setup a search vector as a virtual column. The
+        # options are dev-friendly and controls how the vector function will be
+        # defined
+        #
+        # === Options
+        # [:columns]
+        #   The list of columns that will be used to create the search vector.
+        #   It can be a single column, an array of columns, or a hash as a
+        #   combination of column name and weight (A, B, C, or D).
+        # [:language]
+        #   Specify the language config to be used for the search vector. If a
+        #   string is provided, then the value will be statically embedded. If a
+        #   symbol is provided, then it will reference another column.
+        # [:stored]
+        #   Specify if the value should be stored in the database. As of now,
+        #   PostgreSQL only supports `true`, which will create a stored column.
+        def add_search_vector(table, name, columns, options = {})
+          options = Builder.search_vector_options(columns: columns, **options)
+          add_column(table, name, options.delete(:type), options)
+        end
+
         # Changes the enumerator by adding new values
         #
         # Example:
@@ -48,6 +61,7 @@ module Torque
         #   add_enum_values 'status', ['baz'], after: 'foo'
         #   add_enum_values 'status', ['baz'], prepend: true
         def add_enum_values(name, values, options = {})
+          name   = sanitize_name_with_schema(name, options)
           before = options.fetch(:before, false)
           after  = options.fetch(:after,  false)
 
@@ -59,7 +73,7 @@ module Torque
             reference = "BEFORE #{before}" unless before == false
             reference = "AFTER  #{after}"  unless after == false
             execute <<-SQL.squish
-              ALTER TYPE #{quote_type_name(name, options[:schema])}
+              ALTER TYPE #{quote_type_name(name)}
               ADD VALUE #{value} #{reference}
             SQL
 
@@ -77,34 +91,26 @@ module Torque
           SQL
         end
 
-        # Rewrite the method that creates tables to easily accept extra options
-        def create_table(table_name, **options, &block)
-          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
-
-          options[:id] = false if options[:inherits].present? &&
-            options[:primary_key].blank? && options[:id].blank?
 
-          super table_name, **options, &block
-        end
+        # Add the schema option when extracting table options
+        def table_options(table_name)
+          options = super
 
-        # Simply add the schema to the table name when changing a table
-        def change_table(table_name, **options)
-          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
-          super table_name, **options
-        end
+          if PostgreSQL.config.schemas.enabled
+            table, schema = table_name.split('.').reverse
+            if table.present? && schema.present? && schema != current_schema
+              options[:schema] = schema
+            end
+          end
 
-        # Simply add the schema to the table name when dropping a table
-        def drop_table(table_name, **options)
-          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
-          super table_name, **options
-        end
+          if options[:options]&.start_with?('INHERITS (')
+            options.delete(:options)
 
-        # Add the schema option when extracting table options
-        def table_options(table_name)
-          parts = table_name.split('.').reverse
-          return super unless parts.size == 2 && parts[1] != 'public'
+            tables = inherited_table_names(table_name)
+            options[:inherits] = tables.one? ? tables.first : tables
+          end
 
-          (super || {}).merge(schema: parts[1])
+          options
         end
 
         # When dumping the schema we need to add all schemas, not only those
@@ -112,7 +118,10 @@ module Torque
         def quoted_scope(name = nil, type: nil)
           return super unless name.nil?
 
-          super.merge(schema: "ANY ('{#{user_defined_schemas.join(',')}}')")
+          scope = super
+          global = scope[:schema].start_with?('ANY (')
+          scope[:schema] = "ANY ('{#{user_defined_schemas.join(',')}}')"
+          scope
         end
 
         # Fix the query to include the schema on tables names when dumping
@@ -135,6 +144,12 @@ module Torque
             super(table_name.split('.').last, column_name, suffix)
           end
 
+          # Helper for supporting schema name in several methods
+          def sanitize_name_with_schema(name, options)
+            return name if (schema = options&.delete(:schema)).blank?
+            Quoting::Name.new(schema.to_s, name.to_s)
+          end
+
           def quote_enum_values(name, values, options)
             prefix = options[:prefix]
             prefix = name if prefix === true

data/lib/torque/postgresql/arel/infix_operation.rb

@@ -3,39 +3,26 @@
 module Torque
   module PostgreSQL
     module Arel
-      nodes = ::Arel::Nodes
-      inflix = nodes::InfixOperation
-      visitors = ::Arel::Visitors::PostgreSQL
-      default_alias = :visit_Arel_Nodes_InfixOperation
-
       Math = Module.new
-      INFLIX_OPERATION = {
-        'Overlaps'          => :'&&',
-        'Contains'          => :'@>',
-        'ContainedBy'       => :'<@',
-        'HasKey'            => :'?',
-        'HasAllKeys'        => :'?&',
-        'HasAnyKeys'        => :'?|',
-        'StrictlyLeft'      => :'<<',
-        'StrictlyRight'     => :'>>',
-        'DoesntRightExtend' => :'&<',
-        'DoesntLeftExtend'  => :'&>',
-        'AdjacentTo'        => :'-|-',
-      }.freeze
 
-      INFLIX_OPERATION.each do |operator_name, operator|
-        next if nodes.const_defined?(operator_name)
+      def self.build_operations(operations)
+        default_alias = :visit_Arel_Nodes_InfixOperation
+
+        operations&.each do |name, operator|
+          klass_name = name.to_s.camelize
+          next if ::Arel::Nodes.const_defined?(klass_name)
 
-        klass = Class.new(inflix)
-        klass.send(:define_method, :initialize) { |*args| super(operator, *args) }
+          klass = Class.new(::Arel::Nodes::InfixOperation)
+          operator = (-operator).to_sym
+          klass.send(:define_method, :initialize) { |*args| super(operator, *args) }
 
-        nodes.const_set(operator_name, klass)
-        visitors.send(:alias_method, :"visit_Arel_Nodes_#{operator_name}", default_alias)
+          ::Arel::Nodes.const_set(klass_name, klass)
+          visitor = :"visit_Arel_Nodes_#{klass_name}"
+          ::Arel::Visitors::PostgreSQL.send(:alias_method, visitor, default_alias)
 
-        # Don't worry about quoting here, if the right side is something that
-        # doesn't need quoting, it will leave it as it is
-        Math.send(:define_method, operator_name.underscore) do |other|
-          klass.new(self, other)
+          # Don't worry about quoting here, if the right side is something that
+          # doesn't need quoting, it will leave it as it is
+          Math.send(:define_method, klass_name.underscore) { |other| klass.new(self, other) }
         end
       end
 

data/lib/torque/postgresql/arel/nodes.rb

@@ -13,7 +13,7 @@ module Torque
           include ::Arel::Math
 
           def initialize(left, right, array = false)
-            right = right.to_s
+            right = +right.to_s
             right << '[]' if array
             super left, right
           end
@@ -24,7 +24,7 @@ module Torque
       ::Arel.define_singleton_method(:array) do |*values, cast: nil|
         values = values.first if values.size.eql?(1) && values.first.is_a?(::Enumerable)
         result = ::Arel::Nodes.build_quoted(values)
-        result = result.cast(cast, true) if cast.present?
+        result = result.pg_cast(cast, true) if cast.present?
         result
       end
 

data/lib/torque/postgresql/arel/operations.rb

@@ -6,10 +6,16 @@ module Torque
       module Operations
 
         # Create a cast operation
-        def cast(type, array = false)
+        def pg_cast(type, array = false)
           Nodes::Cast.new(self, type, array)
         end
 
+        # Make sure to add proper support over AR's own +cast+ method while
+        # still allow attributes to be casted
+        def cast(type, array = false)
+          defined?(super) && !array ? super(type) : pg_cast(type, array)
+        end
+
       end
 
       ::Arel::Attributes::Attribute.include(Operations)

data/lib/torque/postgresql/arel/visitors.rb

@@ -4,13 +4,6 @@ module Torque
   module PostgreSQL
     module Arel
       module Visitors
-        # Enclose select manager with parenthesis
-        # :TODO: Remove when checking the new version of Arel
-        def visit_Arel_SelectManager(o, collector)
-          collector << '('
-          visit(o.ast, collector) << ')'
-        end
-
         # Add ONLY modifier to query
         def visit_Arel_Nodes_JoinSource(o, collector)
           collector << 'ONLY ' if o.only?
@@ -26,8 +19,9 @@ module Torque
         # Allow quoted arrays to get here
         def visit_Arel_Nodes_Casted(o, collector)
           value = o.value_for_database
-          return super unless value.is_a?(::Enumerable)
-          quote_array(value, collector)
+          klass = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array::Data
+          return super unless value.is_a?(klass)
+          quote_array(value.values, collector)
         end
 
         ## TORQUE VISITORS

data/lib/torque/postgresql/associations/association_scope.rb

@@ -4,6 +4,15 @@ module Torque
   module PostgreSQL
     module Associations
       module AssociationScope
+        # A customized predicate builder for array attributes that can be used
+        # standalone and changes the behavior of the blank state
+        class PredicateBuilderArray
+          include PredicateBuilder::ArrayHandler
+
+          def call_with_empty(attribute)
+            '1=0' # Does not match records with empty arrays
+          end
+        end
 
         module ClassMethods
           def get_bind_values(*)
@@ -13,45 +22,34 @@ module Torque
 
         private
 
-          # When the relation is connected through an array, intercept the
-          # condition builder and uses an overlap condition building it on
-          # +build_id_constraint+
+          # When loading a join by value (last as in we know which records to
+          # load) only has many array need to have a different behavior, so it
+          # can properly match array values
           def last_chain_scope(scope, reflection, owner)
             return super unless reflection.connected_through_array?
+            return super if reflection.macro == :belongs_to_many
 
-            keys = reflection.join_keys
-            value = transform_value(owner[keys.foreign_key])
-            constraint = build_id_constraint(reflection, keys, value, true)
+            constraint = PredicateBuilderArray.new.call_for_array(
+              reflection.array_attribute,
+              transform_value(owner[reflection.join_foreign_key]),
+            )
 
             scope.where!(constraint)
           end
 
-          # When the relation is connected through an array, intercept the
-          # condition builder and uses an overlap condition building it on
-          # +build_id_constraint+
+          # When loading a join by reference (next as in we don't know which
+          # records to load), it can take advantage of the new predicate builder
+          # to figure out the most optimal way to connect both properties
           def next_chain_scope(scope, reflection, next_reflection)
             return super unless reflection.connected_through_array?
 
-            keys = reflection.join_keys
-            foreign_table = next_reflection.aliased_table
-
-            value = foreign_table[keys.foreign_key]
-            constraint = build_id_constraint(reflection, keys, value)
+            primary_key = reflection.aliased_table[reflection.join_primary_key]
+            foreign_key = next_reflection.aliased_table[reflection.join_foreign_key]
+            constraint = PredicateBuilder::ArelAttributeHandler.call(primary_key, foreign_key)
 
             scope.joins!(join(foreign_table, constraint))
           end
 
-          # Trigger the same method on the relation which will build the
-          # constraint condition using array logics
-          def build_id_constraint(reflection, keys, value, bind_param = false)
-            table = reflection.aliased_table
-            value = Array.wrap(value).map do |value|
-              build_bind_param_for_constraint(reflection, value, keys.foreign_key)
-            end if bind_param
-
-            reflection.build_id_constraint(table[keys.key], value)
-          end
-
           # For array-like values, it needs to call the method as many times as
           # the array size
           def transform_value(value)
@@ -61,12 +59,6 @@ module Torque
               value_transformation.call(value)
             end
           end
-
-          def build_bind_param_for_constraint(reflection, value, foreign_key)
-            ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
-              foreign_key, value, reflection.klass.attribute_types[foreign_key],
-            ))
-          end
       end
 
       ::ActiveRecord::Associations::AssociationScope.singleton_class.prepend(AssociationScope::ClassMethods)

data/lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -70,6 +70,27 @@ module Torque
           @_building_changes = nil
         end
 
+        def trigger(prefix, before_ids, after_ids)
+          removed_ids = before_ids - after_ids
+          added_ids = after_ids - before_ids
+
+          if removed_ids.any?
+            callbacks_for(method = :"#{prefix}_remove").each do |callback|
+              target_scope.find(removed_ids).each do |record|
+                callback.call(method, owner, record)
+              end
+            end
+          end
+
+          if added_ids.any?
+            callbacks_for(method = :"#{prefix}_add").each do |callback|
+              target_scope.find(added_ids).each do |record|
+                callback.call(method, owner, record)
+              end
+            end
+          end
+        end
+
         ## HAS MANY
         def handle_dependency
           case options[:dependent]
@@ -193,6 +214,10 @@ module Torque
             owner.class.columns_hash[source_attr].default
           end
 
+          def callback(*)
+            true # This is handled/trigger when the owner record actually changes
+          end
+
           ## HAS MANY
           def replace_records(*)
             build_changes(true) { super }

data/lib/torque/postgresql/associations/builder/belongs_to_many.rb

@@ -21,6 +21,7 @@ module Torque
             super
             add_touch_callbacks(model, reflection)   if reflection.options[:touch]
             add_default_callbacks(model, reflection) if reflection.options[:default]
+            add_change_callbacks(model, reflection)
           end
 
           def self.define_readers(mixin, name)
@@ -94,6 +95,21 @@ module Torque
             end
           end
 
+          def self.add_change_callbacks(model, reflection)
+            foreign_key = reflection.foreign_key
+            name = reflection.name
+
+            model.before_save ->(record) do
+              before, after = record.changes[foreign_key]
+              record.association(name).trigger(:before, before, after) if before && after
+            end
+
+            model.after_save ->(record) do
+              before, after = record.previous_changes[foreign_key]
+              record.association(name).trigger(:after, before, after) if before && after
+            end
+          end
+
           def self.add_destroy_callbacks(model, reflection)
             model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
           end

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

@@ -6,6 +6,7 @@ module Torque
       module Builder
         class Enum
           VALID_TYPES = %i[enum enum_set].freeze
+          FN = '::Torque::PostgreSQL::FN'
 
           attr_accessor :klass, :attribute, :subtype, :options, :values,
             :klass_module, :instance_module
@@ -154,15 +155,17 @@ module Torque
             def set_scopes
               cast_type = subtype.name.chomp('[]')
               klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def has_#{attribute.pluralize}(*values)                             # def has_roles(*values)
-                  attr = arel_table['#{attribute}']                                 #   attr = arel_table['role']
-                  where(attr.contains(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.contains(::Arel.array(values, cast: 'roles')))
-                end                                                                 # end
-
-                def has_any_#{attribute.pluralize}(*values)                         # def has_roles(*values)
-                  attr = arel_table['#{attribute}']                                 #   attr = arel_table['role']
-                  where(attr.overlaps(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.overlaps(::Arel.array(values, cast: 'roles')))
-                end                                                                 # end
+                def has_#{attribute.pluralize}(*values)                     # def has_roles(*values)
+                  attr = arel_table['#{attribute}']                         #   attr = arel_table['role']
+                  value = #{FN}.bind_with(attr, values)                     #   value = ::Torque::PostgreSQL::FN.bind_with(attr, values)
+                  where(attr.contains(value.pg_cast('#{cast_type}[]')))     #   where(attr.contains(value.pg_cast('roles[]')))
+                end                                                         # end
+
+                def has_any_#{attribute.pluralize}(*values)                 # def has_any_roles(*values)
+                  attr = arel_table['#{attribute}']                         #   attr = arel_table['role']
+                  value = #{FN}.bind_with(attr, values)                     #   value = ::Torque::PostgreSQL::FN.bind_with(attr, values)
+                  where(attr.overlaps(value.pg_cast('#{cast_type}[]')))     #   where(attr.overlaps(value.pg_cast('roles[]')))
+                end                                                         # end
               RUBY
             end
 

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        class FullTextSearch
+          attr_accessor :klass, :attribute, :options, :klass_module,
+            :default_rank, :default_order, :default_language
+
+          def initialize(klass, attribute, options = {})
+            @klass = klass
+            @attribute = attribute
+            @options = options
+
+            @default_rank = options[:with_rank] == true ? 'rank' : options[:with_rank]&.to_s
+
+            @default_order =
+              case options[:order]
+              when :asc, true then :asc
+              when :desc then :desc
+              else false
+              end
+
+            @default_language = options[:language] if options[:language].is_a?(String) ||
+              options[:language].is_a?(Symbol)
+            @default_language ||= PostgreSQL.config.full_text_search.default_language.to_s
+          end
+
+          # What is the name of the scope to be added to the model
+          def scope_name
+            @scope_name ||= [
+              options[:prefix],
+              :full_text_search,
+              options[:suffix],
+            ].compact.join('_')
+          end
+
+          # Just check if the scope name is already defined
+          def conflicting?
+            return if options[:force] == true
+
+            if klass.dangerous_class_method?(scope_name)
+              raise Interrupt, scope_name.to_s
+            end
+          end
+
+          # Create the proper scope
+          def build
+            @klass_module = Module.new
+            add_scope_to_module
+            klass.extend klass_module
+          end
+
+          # Creates a class method as the scope that builds the full text search
+          #
+          # def full_text_search(value, order: :asc, rank: :rank, language: 'english', phrase: true)
+          #   attr = arel_table["search_vector"]
+          #   fn = ::Torque::PostgreSQL::FN
+          #
+          #   lang = language.to_s if !language.is_a?(::Symbol)
+          #   lang ||= arel_table[language.to_s].pg_cast(:regconfig) if has_attribute?(language)
+          #   lang ||= public_send(language) if respond_to?(language)
+          #
+          #   raise ArgumentError, <<~MSG.squish if lang.nil?
+          #     Unable to determine language from #{language.inspect}.
+          #   MSG
+          #
+          #   value = fn.bind(:value, value.to_s, attr.type_caster)
+          #   lang = fn.bind(:lang, lang, attr.type_caster) if lang.is_a?(::String)
+          #
+          #   query = fn.public_send(phrase ? :phraseto_tsquery : :to_tsquery, lang, value)
+          #   ranker = fn.ts_rank(attr, query) if rank || order
+          #
+          #   result = where(fn.infix(:"@@", attr, query))
+          #   result = result.order(ranker.public_send(order == :desc ? :desc : :asc)) if order
+          #   result.select_extra_values += [ranker.as(rank == true ? 'rank' : rank.to_s)] if rank
+          #   result
+          # end
+          def add_scope_to_module
+            klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{scope_name}(value#{scope_args})
+                attr = arel_table['#{attribute}']
+                fn = ::Torque::PostgreSQL::FN
+
+                lang = language.to_s if !language.is_a?(::Symbol)
+                lang ||= arel_table[language.to_s] if has_attribute?(language)
+                lang ||= public_send(language) if respond_to?(language)
+
+                raise ::ArgumentError, <<~MSG.squish if lang.nil?
+                  Unable to determine language from \#{language.inspect}.
+                MSG
+
+                value = fn.bind(:value, value.to_s, attr.type_caster)
+                lang = fn.bind(:lang, lang, attr.type_caster) if lang.is_a?(::String)
+
+                query = fn.public_send(phrase ? :phraseto_tsquery : :to_tsquery, lang, value)
+                ranker = fn.ts_rank(attr, query) if rank || order
+
+                result = where(fn.infix(:"@@", attr, query))
+                result = result.order(ranker.public_send(order == :desc ? :desc : :asc)) if order
+                result.select_extra_values += [ranker.as(rank == true ? 'rank' : rank.to_s)] if rank
+                result
+              end
+            RUBY
+          end
+
+          # Returns the arguments to be used on the scope
+          def scope_args
+            args = +''
+            args << ", order: #{default_order.inspect}"
+            args << ", rank: #{default_rank.inspect}"
+            args << ", language: #{default_language.inspect}"
+            args << ", phrase: true"
+            args
+          end
+        end
+      end
+    end
+  end
+end