torque-postgresql 4.0.1 → 4.1.1

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Composite < ActiveModel::Type::Value
+          ARRAY = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+          DATA = ARRAY::Data
+          ENCODER = PG::TextEncoder::Record.new
+          DECODER = PG::TextDecoder::Record.new
+
+          attr_reader :name
+
+          # The composite type behind the given type, if there is one, wrapped
+          # or not by an array or a delegator
+          def self.from(type)
+            type = OID.unwrap(type)
+            type = type.subtype if type.is_a?(ARRAY)
+            type if type.is_a?(self)
+          end
+
+          def self.create(row, type_map)
+            oid_klass = new(row['typname'])
+            type_map.register_type(row['oid'].to_i, oid_klass)
+            type_map.register_type(row['typarray'].to_i, ARRAY.new(oid_klass, row['typdelim']))
+          end
+
+          def initialize(name)
+            @name = name.to_s.freeze
+          end
+
+          # The class that represents the composite type, loaded in a lazy way.
+          # It cannot be memoized here because Rails freezes the types it
+          # resolves through the type map, so the lookup owns the cache
+          def klass
+            Attributes::Composite.lookup(name)
+          end
+
+          # The ordered list of columns of the composite type, as a hash of
+          # name and type
+          def columns
+            klass.columns
+          end
+
+          def type
+            :composite
+          end
+
+          def cast(value)
+            case value
+            when klass then value
+            when ::Hash then build(value)
+            when DATA then deserialize(value)
+            when ::String then deserialize(value)
+            when ::Array then build(columns.keys.zip(value).to_h)
+            else value
+            end
+          end
+
+          # A record that was already serialized comes back as the encoder and
+          # its values, which is how it is kept around for dirty tracking
+          def deserialize(value)
+            return if value.nil?
+
+            fields = value.is_a?(DATA) ? value.values : DECODER.decode(value)
+            instance = klass.new
+            set = attributes_of(instance)
+
+            columns.each_key.with_index do |attr_name, idx|
+              set.write_from_database(attr_name, fields[idx])
+            end
+
+            instance
+          end
+
+          # The record is handed over to the adapter as an encoder and its
+          # values, the same way arrays are, so that columns are type casted by
+          # the connection right before the record literal is built. Values come
+          # from the record itself, so that types declared by the class, like
+          # encrypted ones, are the ones being applied
+          def serialize(value)
+            return if value.nil?
+
+            set = attributes_of(cast(value))
+            values = columns.each_key.map { |attr_name| set[attr_name].value_for_database }
+
+            DATA.new(ENCODER, values)
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
+
+          def ==(other)
+            other.class == self.class && other.name == name
+          end
+          alias eql? ==
+
+          def hash
+            [self.class, name].hash
+          end
+
+          private
+
+            def build(attrs)
+              klass.new(**attrs.symbolize_keys)
+            end
+
+            def attributes_of(record)
+              record.instance_variable_get(:@attributes)
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -60,7 +60,7 @@ module Torque
               return value if value.is_a?(@klass)
               @klass.new(value)
             rescue Attributes::Enum::EnumError
-              nil
+              value
             end
 
         end

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

@@ -42,8 +42,8 @@ module Torque
               return if value.blank?
               return value if value.is_a?(@klass)
               @klass.new(value)
-            rescue Attributes::EnumSet::EnumSetError
-              nil
+            rescue Attributes::Enum::EnumError
+              ::Array.wrap(value)
             end
 
         end

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

@@ -36,7 +36,7 @@ module Torque
               end
               parts_to_duration(parts.compact)
             when ::Array
-              value.compact!
+              value = value.compact
               parts = CAST_PARTS.drop(6 - value.size).zip(value).to_h
               parts_to_duration(parts)
             when ::Hash

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

@@ -2,7 +2,7 @@
 
 module Torque
   module PostgreSQL
-    class Line < Struct.new(:slope, :intercept)
+    class Line < ::Struct.new(:slope, :intercept)
       alias c intercept
       alias c= intercept=
 

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'ltree'
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        # Same as a path, but the items are the pure parts of a pattern: +:any+
+        # for a star, a Range for a quantified star and an Array for a group of
+        # alternatives. Everything else is a label, written as it appears in SQL
+        class Lquery < Ltree
+          STAR = /\A\*\{(?<min>\d+)?(?<comma>,)?(?<max>\d+)?\}\z/
+
+          def type
+            :lquery
+          end
+
+          private
+
+            def value_class
+              LQuery
+            end
+
+            def items_of(entry, sanitize)
+              case entry
+              when ::Symbol then entry == :any ? [:any] : super
+              when ::Range then [entry]
+              when ::Array then [entry.flat_map { |item| items_of(item, sanitize) }]
+              else super
+              end
+            end
+
+            def compile(item)
+              case item
+              when ::Symbol then item == :any ? '*' : item.to_s
+              when ::Range then quantifier(item)
+              when ::Array then item.map { |entry| compile(entry) }.join('|')
+              else item.to_s
+              end
+            end
+
+            def quantifier(range)
+              min = range.begin
+              max = range.end
+              max -= 1 if max && range.exclude_end?
+
+              return '*' if min.nil? && max.nil?
+              return "*{#{min}}" if min == max
+
+              "*{#{min},#{max}}"
+            end
+
+            def parse(text)
+              return :any if text == '*'
+              return text.split('|') if text.include?('|') && !text.match?(/[!{]/)
+
+              match = text.match(STAR)
+              return text if match.nil?
+
+              min = match[:min]&.to_i
+              max = match[:comma] ? match[:max]&.to_i : min
+              min..max
+            end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        # Moves a label path between the shapes the gem accepts, its pure list
+        # of items and the text form PostgreSQL stores. Nothing is validated
+        # here, that is left to PostgreSQL
+        class Ltree < ActiveModel::Type::Value
+
+          def type
+            :ltree
+          end
+
+          def cast(value)
+            return value if value.is_a?(value_class)
+            return if value.blank?
+
+            value_class.new(value)
+          end
+
+          def serialize(value)
+            path = cast(value)
+            path.map { |item| compile(item) }.join('.') unless path.nil?
+          end
+
+          def deserialize(value)
+            return if value.nil?
+
+            value_class.new(value, sanitize: false)
+          end
+
+          def items_for(value, sanitize: true)
+            ::Array.wrap(value).flat_map { |entry| items_of(entry, sanitize) }
+          end
+
+          def type_cast_for_schema(value)
+            serialize(value).inspect
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value != serialize(new_value)
+          end
+
+          def ==(other)
+            other.class == self.class
+          end
+          alias eql? ==
+
+          def hash
+            self.class.hash
+          end
+
+          private
+
+            def value_class
+              LTree
+            end
+
+            def items_of(entry, sanitize)
+              return items_for(LTree.compatible(entry), sanitize: sanitize) if LTree.compatible?(entry)
+
+              case entry
+              when LTree, LQuery then entry.items
+              when ::Array then items_for(entry, sanitize: sanitize)
+              when ::ActiveRecord::Base then labels_of(record_label(entry), sanitize)
+              else labels_of(entry.to_s, sanitize)
+              end
+            end
+
+            def labels_of(text, sanitize)
+              text = sanitize(text) if sanitize
+              text.split('.').map { |item| parse(item) }
+            end
+
+            def record_label(record)
+              id = record.id
+              raise ArgumentError, <<~MSG.squish if id.nil?
+                Unable to use #{record.class.name} as a label because its
+                #{record.class.primary_key} is still empty.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if id.is_a?(::Array)
+                Unable to use #{record.class.name} as a label because it has a
+                composite primary key, which cannot be a single label.
+              MSG
+
+              id.to_s
+            end
+
+            def sanitize(text)
+              replacements = PostgreSQL.config.ltree.sanitize
+              return text if replacements.blank?
+
+              text.gsub(Regexp.union(replacements.keys), replacements)
+            end
+
+            def compile(item)
+              item.to_s
+            end
+
+            def parse(text)
+              text
+            end
+
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@
 
 module Torque
   module PostgreSQL
-    class Segment < Struct.new(:point0, :point1)
+    class Segment < ::Struct.new(:point0, :point1)
       def x1=(value)
         self.point0 = new_point(value, y1)
       end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Struct < ActiveRecord::Type::Json
+          attr_reader :klass, :type, :backfill
+
+          # A comparable representation of a struct-backed value, based on the
+          # values it exposes instead of the document it generates, so that
+          # non-deterministic types like encrypted attributes stay stable
+          def self.state(value)
+            case value
+            when nil then nil
+            when ::Array then value.map { |item| state(item) }
+            else value.respond_to?(:attributes) ? [value.class, value.attributes] : value
+            end
+          end
+
+          def initialize(klass, type: :jsonb, backfill: nil)
+            super()
+            @klass = klass
+            @type = type
+            @backfill = backfill
+          end
+
+          def cast(value)
+            case value
+            when klass then value
+            when ::Hash then build(value)
+            when ::String then cast(parse(value))
+            else value
+            end
+          end
+
+          def deserialize(value)
+            build(parse(value), from_database: true, blank: true)
+          end
+
+          def serialize(value)
+            case value
+            when klass then empty?(value) ? nil : super(document(value))
+            when nil then nil
+            else super
+            end
+          end
+
+          def changed?(old_value, new_value, _new_value_before_cast)
+            Struct.state(old_value) != Struct.state(new_value)
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            Struct.state(without_backfill.deserialize(raw_old_value)) != Struct.state(new_value)
+          end
+
+          # The same type, but reading documents exactly as they are stored, so
+          # that backfilled properties are seen as changes
+          def without_backfill
+            return self if backfill.nil?
+            @without_backfill ||= self.class.new(klass, type: type)
+          end
+
+          def empty?(value)
+            document(value).empty?
+          end
+
+          # The value as it goes inside another document, which is a hash, and
+          # not the encoded JSON that a column receives
+          def document_for(value)
+            value.nil? ? nil : document(value)
+          end
+
+          # The hash that represents the value on the database, holding only the
+          # properties that were actually written to it. Properties backed by
+          # another struct are kept as documents, so that they are not stored as
+          # an encoded string inside this one
+          def document(value)
+            set = value.instance_variable_get(:@attributes)
+            set.keys.to_h do |name|
+              attribute = set[name]
+              type = OID.unwrap(attribute.type)
+
+              next [name, type.document_for(attribute.value)] if type.is_a?(Struct)
+              [name, attribute.value_for_database]
+            end
+          end
+
+          def blank_document
+            {}
+          end
+
+          def ==(other)
+            other.class == self.class && other.klass == klass && other.type == type
+          end
+          alias eql? ==
+
+          def hash
+            [self.class, klass, type].hash
+          end
+
+          private
+
+            def parse(value)
+              return value unless value.is_a?(::String)
+              ActiveSupport::JSON.decode(value) rescue nil
+            end
+
+            def build(data, from_database: false, blank: false)
+              instance = klass.new
+              blank!(instance) if blank
+              return instance unless data.is_a?(::Hash)
+
+              from_database ? load(instance, data) : instance.assign_attributes(data)
+              instance
+            end
+
+            # Reset the instance to the state of an empty document, keeping the
+            # class-level defaults that were marked to be backfilled
+            def blank!(instance)
+              return if backfill == true
+
+              keep = ::Array.wrap(backfill).map(&:to_s)
+              set = instance.instance_variable_get(:@attributes).map do |attribute|
+                next attribute if keep.include?(attribute.name)
+                ActiveModel::Attribute.uninitialized(attribute.name, attribute.type)
+              end
+
+              instance.instance_variable_set(:@attributes, set)
+            end
+
+            # Properties that the class doesn't declare are kept as they are
+            # stored, regardless of the class being strict about them or not
+            def load(instance, data)
+              default = ActiveModel::Type.default_value
+              set = instance.instance_variable_get(:@attributes)
+
+              data.each do |key, value|
+                if klass.attribute_names.include?(key = key.to_s)
+                  set.write_from_database(key, value)
+                else
+                  set[key] = ActiveModel::Attribute.from_database(key, value, default)
+                end
+              end
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class StructList < Struct
+          def cast(value)
+            case value
+            when ::String then cast(parse(value))
+            when ::Array then value.map { |item| super(item) }
+            else value
+            end
+          end
+
+          def deserialize(value)
+            ::Array.wrap(parse(value)).map do |item|
+              build(item, from_database: true, blank: true)
+            end
+          end
+
+          def serialize(value)
+            case value
+            when ::Array then value.empty? ? nil : encode(value)
+            when nil then nil
+            else super
+            end
+          end
+
+          def document_for(value)
+            ::Array.wrap(value).map { |item| item.is_a?(klass) ? document(item) : item }
+          end
+
+          def empty?(value)
+            value.is_a?(::Array) ? value.empty? : super
+          end
+
+          def blank_document
+            []
+          end
+
+          private
+
+            def encode(items)
+              hashes = items.map { |item| item.is_a?(klass) ? document(item) : item }
+              ActiveSupport::JSON.encode(hashes)
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class StructSet < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+          def deserialize(value)
+            value.nil? ? [] : super
+          end
+
+          def serialize(value)
+            return if value.is_a?(::Array) && value.empty?
+            super
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            Struct.state(without_backfill.deserialize(raw_old_value)) !=
+              Struct.state(new_value)
+          end
+
+          def without_backfill
+            return self if subtype.backfill.nil?
+            @without_backfill ||= self.class.new(subtype.without_backfill, delimiter)
+          end
+
+          def empty?(value)
+            value.is_a?(::Array) ? value.empty? : subtype.empty?(value)
+          end
+
+          def blank_document
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,2 +1,15 @@
 require_relative 'oid/array'
 require_relative 'oid/range'
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        def self.unwrap(type)
+          type = type.__getobj__ while type.is_a?(Delegator)
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module Torque
 
         # Quotes type names for use in SQL queries.
         def quote_type_name(name, *args)
-          QUOTED_TYPE_NAMES[args] ||= begin
+          QUOTED_TYPE_NAMES[[name.to_s, *args]] ||= begin
             name = name.to_s
             args << 'public' if args.empty? && !name.include?('.')
             quote_identifier_name(name, *args)
@@ -36,11 +36,20 @@ module Torque
               lookup_cast_type(column.sql_type)
             elsif column.is_a?(Column) && column.array?
               # When using +change_column_default+
-              lookup_cast_type_from_column(column)
+              lookup_cast_type_for_column(column)
             end
 
           type.nil? ? super : quote(type.serialize(value.to_a))
         end
+
+        # Rails 8.1 dropped +lookup_cast_type_from_column+, and the sql_type of
+        # an array column does not carry the array part, so only the oid can
+        # resolve the real type
+        def lookup_cast_type_for_column(column)
+          return lookup_cast_type_from_column(column) unless AR810
+
+          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        end
       end
     end
   end