torque-postgresql 0.2.16 → 1.0.0

data/lib/torque/postgresql/adapter/oid/range.rb

@@ -0,0 +1,52 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Range < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range
+          HASH_PICK = %i[from start end to].freeze
+
+          module Comparasion
+            def <=>(other)
+              return super unless other.acts_like?(:date) || other.acts_like?(:time)
+              other = other.to_time if other.acts_like?(:date)
+              super other.to_i
+            end
+          end
+
+          def cast_value(value)
+            case value
+            when Array
+              cast_custom(value[0], value[1])
+            when Hash
+              pieces = value.with_indifferent_access.values_at(*HASH_PICK)
+              cast_custom(pieces[0] || pieces[1], pieces[2] || pieces[3])
+            else
+              super
+            end
+          end
+
+          private
+
+            def cast_custom(from, to)
+              from = custom_cast_single(from, true)
+              to = custom_cast_single(to)
+              ::Range.new(from, to)
+            end
+
+            def custom_cast_single(value, negative = false)
+              value.blank? ? custom_infinity(negative) : subtype.deserialize(value)
+            end
+
+            def custom_infinity(negative)
+              negative ? -::Float::INFINITY : ::Float::INFINITY
+            end
+        end
+
+        ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID.send(:remove_const, :Range)
+        ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID.const_set(:Range, Range)
+
+        ::Float.prepend(Range::Comparasion)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/segment.rb

@@ -0,0 +1,73 @@
+module Torque
+  module PostgreSQL
+    class Segment < Struct.new(:point0, :point1)
+      def x1=(value)
+        self.point0 = new_point(value, y1)
+      end
+
+      def x1
+        point0.x
+      end
+
+      def y1=(value)
+        self.point0 = new_point(x1, value)
+      end
+
+      def y1
+        point0.y
+      end
+
+      def x2=(value)
+        self.point1 = new_point(value, y2)
+      end
+
+      def x2
+        point1.x
+      end
+
+      def y2=(value)
+        self.point1 = new_point(x2, value)
+      end
+
+      def y2
+        point1.y
+      end
+
+      private
+
+        def new_point(x, y)
+          Torque::PostgreSQL.config.geometry.point_class.new(x, y)
+        end
+    end
+
+    config.geometry.segment_class ||= ::ActiveRecord.const_set('Segment', Class.new(Segment))
+
+    module Adapter
+      module OID
+        class Segment < Torque::PostgreSQL::GeometryBuilder
+
+          PIECES = %i[x1 y1 x2 y2].freeze
+          FORMATION = '((%s,%s),(%s,%s))'.freeze
+
+          protected
+
+            def point_class
+              Torque::PostgreSQL.config.geometry.point_class
+            end
+
+            def build_klass(*args)
+              return nil if args.empty?
+              check_invalid_format!(args)
+
+              x1, y1, x2, y2 = args.try(:first, pieces.size)&.map(&:to_f)
+              config_class.new(
+                point_class.new(x1, y1),
+                point_class.new(x2, y2),
+              )
+            end
+
+        end
+      end
+    end
+  end
+end

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

@@ -17,6 +17,27 @@ module Torque
           Name.new(schema, table).quoted
         end
 
+        def quote_default_expression(value, column)
+          if value.is_a?(::Enumerable)
+            quote(value) + '::' + column.sql_type
+          else
+            super
+          end
+        end
+
+        private
+
+          def _quote(value)
+            return super unless value.is_a?(Array)
+
+            values = value.map(&method(:quote))
+            "ARRAY[#{values.join(','.freeze)}]"
+          end
+
+          def _type_cast(value)
+            return super unless value.is_a?(Array)
+            value.map(&method(:quote)).join(','.freeze)
+          end
       end
     end
   end

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

@@ -20,6 +20,13 @@ module Torque
           end
         end
 
+        # Creates a column with an enum array type, needing to specify the
+        # subtype, which is basically the name of the type defined prior
+        # creating the column
+        def enum_set(*args, **options)
+          super(*args, **options.merge(array: true))
+        end
+
       end
 
       module TableDefinition

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

@@ -10,6 +10,15 @@ module Torque
           end
         end
 
+        # Translate +:enum_set+ into +:enum+
+        def schema_type(column)
+          if column.type == :enum_set
+            :enum
+          else
+            super
+          end
+        end
+
         # Adds +:subtype+ option to the default set
         def prepare_column_options(column)
           spec = super
@@ -24,7 +33,7 @@ module Torque
         private
 
           def schema_subtype(column)
-            column.sql_type.to_sym.inspect if column.type == :enum
+            column.sql_type.to_sym.inspect if column.type == :enum || column.type == :enum_set
           end
 
       end

data/lib/torque/postgresql/arel.rb

@@ -1,3 +1,6 @@
+require_relative 'arel/infix_operation'
 require_relative 'arel/join_source'
+require_relative 'arel/nodes'
+require_relative 'arel/operations'
 require_relative 'arel/select_manager'
 require_relative 'arel/visitors'

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

@@ -0,0 +1,42 @@
+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|
+        klass = Class.new(inflix)
+        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)
+
+        # 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, nodes.build_quoted(other, self))
+        end
+      end
+
+      ::Arel::Nodes::Node.include(Math)
+      ::Arel::Attribute.include(Math)
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module Nodes
+
+        class Cast < ::Arel::Nodes::Binary
+          include ::Arel::Expressions
+          include ::Arel::Predications
+          include ::Arel::AliasPredication
+          include ::Arel::OrderPredications
+          include ::Arel::Math
+
+          def initialize(left, right, array = false)
+            right = right.to_s
+            right << '[]' if array
+            super left, right
+          end
+        end
+
+      end
+
+      ::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
+      end
+
+      ::Arel::Nodes::Function.include(::Arel::Math)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module Operations
+
+        # Create a cast operation
+        def cast(type, array = false)
+          Nodes::Cast.new(self, type, array)
+        end
+
+      end
+
+      ::Arel::Attributes::Attribute.include(Operations)
+      ::Arel::Nodes::SqlLiteral.include(Operations)
+      ::Arel::Nodes::Node.include(Operations)
+    end
+  end
+end

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

@@ -2,7 +2,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
@@ -16,9 +15,36 @@ module Torque
           super
         end
 
+        # Allow quoted arrays to get here
+        def visit_Arel_Nodes_Quoted(o, collector)
+          return super unless o.expr.is_a?(::Enumerable)
+          quote_array(o.expr, collector)
+        end
+
+        # Allow quoted arrays to get here
+        def visit_Arel_Nodes_Casted(o, collector)
+          return super unless o.val.is_a?(::Enumerable)
+          quote_array(o.val, collector)
+        end
+
+        ## TORQUE VISITORS
+        # Allow casting any node
+        def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
+          visit(o.left, collector) << '::' << o.right
+        end
+
+        private
+
+          def quote_array(value, collector)
+            value = value.map(&::Arel::Nodes.method(:build_quoted))
+
+            collector << 'ARRAY['
+            visit_Array(value, collector)
+            collector << ']'
+          end
       end
 
-      ::Arel::Visitors::PostgreSQL.include Visitors
+      ::Arel::Visitors::PostgreSQL.prepend(Visitors)
     end
   end
 end

data/lib/torque/postgresql/associations.rb

@@ -0,0 +1,8 @@
+require_relative 'associations/association'
+require_relative 'associations/association_scope'
+require_relative 'associations/belongs_to_many_association'
+require_relative 'associations/builder'
+require_relative 'associations/preloader'
+
+require_relative 'associations/join_dependency/join_association' \
+  unless Torque::PostgreSQL::AR521

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

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module Association
+
+        def inversed_from(record)
+          return super unless reflection.connected_through_array?
+
+          self.target ||= []
+          self.target.push(record) unless self.target.include?(record)
+          @inversed = self.target.present?
+        end
+
+        private
+
+          def set_owner_attributes(record)
+            return super unless reflection.connected_through_array?
+
+            add_id = owner[reflection.active_record_primary_key]
+            record_fk = reflection.foreign_key
+
+            record[record_fk].push(add_id) unless (record[record_fk] ||= []).include?(add_id)
+          end
+
+      end
+
+      ::ActiveRecord::Associations::Association.prepend(Association)
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Torque
+  module PostgreSQL
+    module Associations
+      module AssociationScope
+
+        module ClassMethods
+          def get_bind_values(*)
+            super.flatten
+          end
+        end
+
+        private
+
+          # When the relation is connected through an array, intercept the
+          # condition builder and uses an overlap condition building it on
+          # +build_id_constraint+
+          def last_chain_scope(scope, *args)
+            # 5.0 table, reflection, owner, association_klass
+            # 5.1 table, reflection, owner
+            # 5.2 reflection, owner
+
+            reflection = args.size.eql?(2) ? args[0] : args[1]
+            return super unless reflection.connected_through_array?
+
+            table = args[0] if args.size > 2
+            keys = args.size.eql?(4) ? reflection.join_keys(args[3]) : reflection.join_keys
+            owner = args.size.eql?(2) ? args[1] : args[2]
+
+            value = transform_value(owner[keys.foreign_key])
+            constraint, binds = build_id_constraint(reflection, keys, value, table, true)
+
+            if Torque::PostgreSQL::AR521
+              scope.where!(constraint)
+            else
+              klass = ::ActiveRecord::Relation::WhereClause
+              scope.where_clause += klass.new([constraint], binds)
+              scope
+            end
+          end
+
+          # When the relation is connected through an array, intercept the
+          # condition builder and uses an overlap condition building it on
+          # +build_id_constraint+
+          def next_chain_scope(scope, *args)
+            # 5.0 table, reflection, association_klass, foreign_table, next_reflection
+            # 5.1 table, reflection, foreign_table, next_reflection
+            # 5.2 reflection, next_reflection
+
+            reflection = args.size.eql?(2) ? args[0] : args[1]
+            return super unless reflection.connected_through_array?
+
+            table = args[0] if args.size > 2
+            next_reflection = args[-1]
+
+            foreign_table = args[-2] if args.size.eql?(5)
+            foreign_table ||= next_reflection.aliased_table
+
+            keys = args.size.eql?(5) ? reflection.join_keys(args[2]) : reflection.join_keys
+
+            value = foreign_table[keys.foreign_key]
+            constraint, *_ = build_id_constraint(reflection, keys, value, table)
+
+            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, table = nil, bind_param = false)
+            table ||= reflection.aliased_table
+            value, binds = build_binds_for_constraint(reflection, value, keys.foreign_key) \
+              if bind_param
+
+            [reflection.build_id_constraint(table[keys.key], value), binds]
+          end
+
+          # For array-like values, it needs to call the method as many times as
+          # the array size
+          def transform_value(value)
+            if value.is_a?(::Enumerable)
+              value.map { |v| value_transformation.call(v) }
+            else
+              value_transformation.call(value)
+            end
+          end
+
+          # When binds are necessary for a constraint, instantiate them
+          if Torque::PostgreSQL::AR521
+            def build_binds_for_constraint(reflection, values, foreign_key)
+              result = Array.wrap(values).map do |value|
+                ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
+                  foreign_key, value, reflection.klass.attribute_types[foreign_key],
+                ))
+              end
+
+              [result, nil]
+            end
+          else
+            def build_binds_for_constraint(reflection, values, foreign_key)
+              type = reflection.klass.attribute_types[foreign_key]
+              parts = Array.wrap(values).map do |value|
+                bind = ::Arel::Nodes::BindParam.new
+                value = ::ActiveRecord::Relation::QueryAttribute.new(foreign_key, value, type)
+                [bind, value]
+              end.to_h
+
+              [parts.keys, parts.values]
+            end
+          end
+
+      end
+
+      ::ActiveRecord::Associations::AssociationScope.singleton_class.prepend(AssociationScope::ClassMethods)
+      ::ActiveRecord::Associations::AssociationScope.prepend(AssociationScope)
+    end
+  end
+end