torque-postgresql 4.0.0 → 4.1.0

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Lquery < ActiveModel::Type::Value
+
+          def type
+            :lquery
+          end
+
+          def cast(value)
+            return if value.blank?
+            return value if value.is_a?(LQuery)
+
+            LQuery.new(value)
+          end
+
+          def deserialize(value)
+            return if value.nil?
+
+            LQuery.load(value)
+          end
+
+          def serialize(value)
+            cast(value)&.to_s
+          end
+
+          def type_cast_for_schema(value)
+            cast(value).to_s.inspect
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value != serialize(new_value)
+          end
+
+          # Types resolved through the type map are deduplicated and frozen, so
+          # they need to be comparable
+          def ==(other)
+            other.is_a?(self.class)
+          end
+          alias eql? ==
+
+          def hash
+            self.class.hash
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class Ltree < ActiveModel::Type::Value
+
+          def type
+            :ltree
+          end
+
+          def cast(value)
+            return if value.blank?
+            return value if value.is_a?(LTree)
+
+            LTree.new(value)
+          end
+
+          def deserialize(value)
+            return if value.nil?
+
+            LTree.load(value)
+          end
+
+          def serialize(value)
+            cast(value)&.to_s
+          end
+
+          def type_cast_for_schema(value)
+            cast(value).to_s.inspect
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value != serialize(new_value)
+          end
+
+          # Types resolved through the type map are deduplicated and frozen, so
+          # they need to be comparable
+          def ==(other)
+            other.is_a?(self.class)
+          end
+          alias eql? ==
+
+          def hash
+            self.class.hash
+          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 = 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/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

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

@@ -18,6 +18,26 @@ module Torque
           names.each { |name| column(name, :virtual, **options) }
         end
 
+        # Add a composite type column to the table
+        def composite(*names, composite_type:, **options)
+          raise ArgumentError, "Missing column name(s) for composite" if names.empty?
+          names.each { |name| column(name, :composite, composite_type: composite_type, **options) }
+        end
+
+        # Add a label tree column to the table. Tree operators are only indexed
+        # by GiST, as in +index: { using: :gist }+, whose default operator class
+        # is already the right one for both a path and an array of paths
+        def ltree(*names, **options)
+          raise ArgumentError, "Missing column name(s) for ltree" if names.empty?
+          names.each { |name| column(name, :ltree, **options) }
+        end
+
+        # Add a label tree pattern column to the table
+        def lquery(*names, **options)
+          raise ArgumentError, "Missing column name(s) for lquery" if names.empty?
+          names.each { |name| column(name, :lquery, **options) }
+        end
+
       end
 
       module TableDefinition
@@ -49,6 +69,32 @@ module Torque
           end
       end
 
+      # Composite types are defined with the same DSL as tables, where declaring
+      # a column adds one, plus the operations that +change_table+ provides
+      class CompositeTypeDefinition < ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+        attr_reader :changes, :removals, :renames
+
+        def initialize(*args, **xargs)
+          super
+
+          @changes = []
+          @removals = []
+          @renames = []
+        end
+
+        def change(name, type, **options)
+          @changes << new_column_definition(name, type, **options)
+        end
+
+        def remove(*names)
+          @removals.concat(names.map(&:to_s))
+        end
+
+        def rename(name, new_name)
+          @renames << [name.to_s, new_name.to_s]
+        end
+      end
+
       # Add exclusive support for versioned commands when importing from schema
       # dump. This ensures that such methods are not available in regular
       # migrations.

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

@@ -34,10 +34,35 @@ module Torque
           def types(stream) # :nodoc:
             super
 
+            composite_types(stream)
+
             versioned_commands(stream, :type)
             versioned_commands(stream, :function)
           end
 
+          # Dump user defined composite types, sorted by their dependencies
+          def composite_types(stream)
+            return unless PostgreSQL.config.composite.enabled
+
+            list = @connection.composite_types
+            list -= @versioned_commands.versions_of('type').map(&:first) \
+              if with_versioned_commands?
+            return if list.empty?
+
+            stream.puts "  # Custom composite types defined in this database."
+            list.each do |name|
+              stream.puts "  create_composite_type #{name.inspect}, force: :cascade do |t|"
+              @connection.columns(name).each do |column|
+                type, colspec = column_spec(column)
+                stream.print "    t.#{type} #{column.name.inspect}"
+                stream.print ", #{format_colspec(colspec)}" if colspec.present?
+                stream.puts
+              end
+              stream.puts "  end"
+              stream.puts
+            end
+          end
+
           def tables(stream) # :nodoc:
             around_tables(stream) { dump_tables(stream) }
           end
@@ -126,13 +151,14 @@ module Torque
           def prepare_column_options(column)
             options = super
             parse_search_vector_options(column, options) if column.type == :tsvector
+            options[:composite_type] = column.sql_type.inspect if column.type == :composite
             options
           end
 
           # Parse the search vector operation into a readable format
           def parse_search_vector_options(column, options)
-            settings = options[:as].scan(SEARCH_VECTOR_SCANNER)
-            return if settings.empty?
+            settings = options[:as]&.scan(SEARCH_VECTOR_SCANNER)
+            return if settings.blank?
 
             languages = settings.map(&:shift).uniq
             return if languages.many?