torque-postgresql 4.0.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e1560c305d73659df33b4dcc71dd57376ab72d898ef1848e54c8aaa5689584e
-  data.tar.gz: 0fc8842730a9970f999b52c6a10feb728f16b79086b4389f114ccca12e24f5a9
+  metadata.gz: 386d035c1a009d6c67f130c50baa9e0db1c417aa79b6190834780855ca92d2ee
+  data.tar.gz: 468a10d17d4ac97b4e83914be5a539e1b2ca78cbb54ae35e9c80fbee41fda18f
 SHA512:
-  metadata.gz: 9985681094dc57004a8d823f5f13d5383d965304336d1b9e4a886fa812e8b9dfca5af93504a7b46ed58e7e508fd0d3c8048d367b5b8c36f42f9dc293f2f556bf
-  data.tar.gz: 4b23fe90238cb6f0f7c424631e381c27b15bc932e69d46d68dfba9f96a39081d40b80a0ff61266ab1122c24f10242c26a1728e5e737ef847a49c403e8b3e9c88
+  metadata.gz: 503443151d99b82e2e76f1d6ed34b6a314e0b8cdd9cd576933879a7a807d33cecd926c48d3809a01fd785d8777d5ae0135c46fb0d9b4c4c347b4457e807cb6ba
+  data.tar.gz: a7bce5728938390a5bb285185c592dfcaf44f5322fb30b46fbc08ba5edeaf7a30d932177f91a685afa35153ff2ed8c5200edeb88058d571f2402f8c9a204b32e

data/Rakefile

@@ -4,8 +4,32 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
+require 'bundler/gem_tasks'
 require 'rdoc/task'
 
+DOCS_PATH = File.expand_path('docs', __dir__)
+
+desc 'Compile the documentation site into docs/_site'
+task :docs do
+  version = File.read(File.expand_path('lib/torque/postgresql/version.rb', __dir__))[/VERSION = '([^']+)'/, 1]
+  published = File.read(File.join(DOCS_PATH, '_config.yml'))[/^gem_version:\s*(\S+)/, 1]
+
+  unless published == version
+    abort <<~MESSAGE
+      docs/_config.yml says gem_version: #{published}, but the gem is #{version}.
+      The site prints that number in its header, so update _config.yml before building.
+    MESSAGE
+  end
+
+  env = { 'BUNDLE_GEMFILE' => File.join(DOCS_PATH, 'Gemfile') }
+  Dir.chdir(DOCS_PATH) { sh(env, 'bundle', 'exec', 'jekyll', 'build') }
+end
+
+# A gem cut from master carries freshly compiled docs; every other branch skips
+# the cost. Publishing docs/_site stays a manual step.
+branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+Rake::Task[:build].enhance([:docs]) if branch == 'master'
+
 RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'Torque::Postgresql'

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

@@ -5,7 +5,7 @@ module Torque
     module Adapter
       module DatabaseStatements
 
-        EXTENDED_DATABASE_TYPES = %i[enum enum_set interval]
+        EXTENDED_DATABASE_TYPES = %i[enum enum_set interval composite ltree lquery]
 
         # Switch between dump mode or not
         def dump_mode!
@@ -73,6 +73,11 @@ module Torque
           if PostgreSQL.config.interval.enabled
             m.register_type 'interval', OID::Interval.new
           end
+
+          if PostgreSQL.config.ltree.enabled
+            m.register_type 'ltree',    OID::Ltree.new
+            m.register_type 'lquery',   OID::Lquery.new
+          end
         end
 
         # :nodoc:
@@ -92,9 +97,10 @@ module Torque
 
           query = <<~SQL
             SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput,
-                   r.rngsubtype, t.typtype, t.typbasetype, t.typarray
+                   r.rngsubtype, t.typtype, t.typbasetype, t.typarray, c.relkind
             FROM pg_type as t
-            LEFT JOIN pg_range as r ON oid = rngtypid
+            LEFT JOIN pg_range as r ON t.oid = rngtypid
+            LEFT JOIN pg_class as c ON c.oid = t.typrelid
             LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
           SQL
@@ -102,19 +108,55 @@ module Torque
           if oids
             query += " AND t.oid IN (%s)" % oids.join(", ")
           else
-            query += " AND t.typtype IN ('e')"
+            conditions = []
+            conditions << "t.typtype IN ('e')" if PostgreSQL.config.enum.enabled
+            conditions << "(t.typtype = 'c' AND c.relkind = 'c')" \
+              if PostgreSQL.config.composite.enabled
+
+            query += " AND (#{conditions.join(' OR ')})"
           end
 
           options = { allow_retry: true, materialize_transactions: false }
           internal_execute(query, 'SCHEMA', **options).each do |row|
-            if row['typtype'] == 'e' && PostgreSQL.config.enum.enabled
-              OID::Enum.create(row, type_map)
+            if row['typtype'] == 'e'
+              OID::Enum.create(row, type_map) if PostgreSQL.config.enum.enabled
+            elsif row['typtype'] == 'c' && row['relkind'] == 'c'
+              OID::Composite.create(row, type_map) if PostgreSQL.config.composite.enabled
             end
           end
         end
 
         def torque_load_additional_types?
-          PostgreSQL.config.enum.enabled
+          PostgreSQL.config.enum.enabled || PostgreSQL.config.composite.enabled
+        end
+
+        # Get the ordered list of columns of a composite type, as a hash of
+        # column name and its proper cast type
+        def composite_column_types(name)
+          rows = query(<<~SQL, 'SCHEMA')
+            SELECT a.attname, a.atttypid, a.atttypmod
+            FROM pg_attribute a
+            WHERE a.attrelid = #{quote(quote_type_name(name).to_s)}::regclass
+              AND a.attnum > 0 AND NOT a.attisdropped
+            ORDER BY a.attnum
+          SQL
+
+          rows.each_with_object({}) do |(attr_name, oid, fmod), hash|
+            hash[attr_name] = get_oid_type(oid.to_i, fmod.to_i, attr_name)
+          end
+        end
+
+        # Get the list of user-defined composite types, sorted so that types
+        # that depend on other composite types come later
+        def composite_types
+          dependencies = composite_type_dependencies
+          result = []
+
+          dependencies.each_key do |name|
+            sort_composite_type(name, dependencies, result)
+          end
+
+          result
         end
 
         # Gets a list of user defined types.
@@ -229,6 +271,46 @@ module Torque
           conditions
         end
 
+        private
+
+          # Every user-defined composite type associated with the list of other
+          # composite types that its columns rely on
+          def composite_type_dependencies
+            rows = select_rows(<<~SQL, 'SCHEMA')
+              SELECT t.typname, t.oid::int, COALESCE(elem.oid, mt.oid)::int AS column_oid
+              FROM pg_type t
+              JOIN pg_class c ON c.oid = t.typrelid AND c.relkind = 'c'
+              JOIN pg_namespace n ON n.oid = t.typnamespace
+              LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0
+                AND NOT a.attisdropped
+              LEFT JOIN pg_type mt ON mt.oid = a.atttypid
+              LEFT JOIN pg_type elem ON elem.oid = mt.typelem AND mt.typelem <> 0
+              WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+              ORDER BY t.oid
+            SQL
+
+            names = rows.to_h { |name, oid, _| [oid, name] }
+            result = names.values.uniq.to_h { |name| [name, []] }
+
+            rows.each do |name, _oid, column_oid|
+              dependency = names[column_oid]
+              result[name] << dependency unless dependency.nil? || dependency == name
+            end
+
+            result
+          end
+
+          # Add the type to the list, but only after every type it depends on
+          def sort_composite_type(name, dependencies, result)
+            return if result.include?(name)
+
+            dependencies[name].each do |dependency|
+              sort_composite_type(dependency, dependencies, result)
+            end
+
+            result << name
+          end
+
       end
     end
   end

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

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module InheritanceStatements
+
+        # Copies created by a sync are named after this, which is how they are
+        # told apart from anything written by hand
+        SYNC_MARKER = 'sync_inh_'
+
+        SYNC_FEATURES = %i[
+          primary_key indexes unique_constraints exclusion_constraints foreign_keys
+        ].freeze
+
+        # PostgreSQL only propagates columns, their defaults and their check
+        # constraints to inherited tables. This copies over everything else that
+        # Rails has a DSL for, from +table_name+ down to its children
+        #
+        # Features default to +true+, so passing one as +false+ excludes it.
+        # Passing any of them as +true+ instead selects only those
+        #
+        # Example:
+        #   sync_inheritance_features :activities
+        #   sync_inheritance_features :activities, %i[activity_books]
+        #   sync_inheritance_features :activities, primary_key: false
+        #   sync_inheritance_features :activities, prune: true
+        def sync_inheritance_features(table_name, children = nil, prune: false, **features)
+          features = sync_inheritance_selection(features)
+
+          sync_inheritance_tree(table_name, children).each do |child, parents|
+            sync_inheritance_into(child, parents, features, prune)
+          end
+        end
+
+        private
+
+          # Resolves which tables to write to, and where each of them pulls from,
+          # with ancestors always coming before their own descendants
+          def sync_inheritance_tree(table_name, children)
+            table_name = table_name.to_s
+            dependencies = inherited_tables
+            descendants = sync_inheritance_descendants(dependencies, table_name)
+
+            targets = descendants
+            unless children.nil?
+              children = Array.wrap(children).map(&:to_s)
+              unknown = children - descendants
+              raise ArgumentError, <<~MSG.squish if unknown.any?
+                #{unknown.to_sentence} #{unknown.one? ? 'does' : 'do'} not inherit
+                from #{table_name}
+              MSG
+
+              targets = descendants & children
+            end
+
+            scope = [table_name] + descendants
+            targets.map { |child| [child, dependencies[child] & scope] }
+          end
+
+          # Walks the inheritance graph breadth-first, so that every table shows
+          # up only after all of its own ancestors
+          def sync_inheritance_descendants(dependencies, table_name)
+            children = {}
+            dependencies.each do |child, parents|
+              parents.each { |parent| (children[parent] ||= []) << child }
+            end
+
+            result = []
+            queue = (children[table_name] || []).dup
+
+            while (item = queue.shift)
+              next if result.include?(item)
+
+              result << item
+              queue.concat(children[item] || [])
+            end
+
+            result
+          end
+
+          # Turns what was asked for into a decision for every single feature
+          def sync_inheritance_selection(features)
+            features = {} if features == true
+            unknown = features.keys - SYNC_FEATURES
+            raise ArgumentError, <<~MSG.squish if unknown.any?
+              Unknown inheritance #{'feature'.pluralize(unknown.size)} #{unknown.to_sentence}
+            MSG
+
+            return SYNC_FEATURES.index_with(true) if features.blank?
+            return SYNC_FEATURES.index_with { |name| features.fetch(name, false) } \
+              if features.value?(true)
+
+            SYNC_FEATURES.index_with { |name| features.fetch(name, true) }
+          end
+
+          def sync_inheritance_into(child, parents, features, prune)
+            return if parents.blank?
+
+            sync_inheritance_primary_key(child, parents) if features[:primary_key]
+            sync_inheritance_unique_constraints(child, parents, prune) \
+              if features[:unique_constraints]
+            sync_inheritance_exclusion_constraints(child, parents, prune) \
+              if features[:exclusion_constraints]
+            sync_inheritance_indexes(child, parents, features, prune) if features[:indexes]
+            sync_inheritance_foreign_keys(child, parents, prune) if features[:foreign_keys]
+          end
+
+          # The only copy that cannot carry the marker, since PostgreSQL names it
+          # after the table and Rails has no way to dump that name back. That is
+          # why it is also the only one that is never pruned
+          def sync_inheritance_primary_key(child, parents)
+            return if primary_keys(child).present?
+
+            parent = parents.find { |item| primary_keys(item).present? }
+            return if parent.nil?
+
+            columns = primary_keys(parent).map { |column| quote_column_name(column) }
+            execute(<<~SQL.squish)
+              ALTER TABLE #{quote_table_name(child)} ADD PRIMARY KEY (#{columns.join(', ')})
+            SQL
+          end
+
+          def sync_inheritance_indexes(child, parents, features, prune)
+            existing = indexes(child)
+            expected = {}
+
+            parents.each do |parent|
+              skip = sync_inheritance_constraint_indexes(parent, features)
+              indexes(parent).each do |index|
+                next if skip.include?(index.name)
+
+                expected[sync_inheritance_name(child, parent, index.name)] ||= index
+              end
+            end
+
+            expected.each do |name, index|
+              next if existing.any? { |item| item.name == name || sync_inheritance_index?(item, index) }
+
+              add_index(child, index.columns, name: name, **sync_inheritance_index_options(index))
+            end
+
+            return unless prune
+
+            # An index that backs a constraint can only leave with it
+            guarded = sync_inheritance_constraint_indexes(child)
+            sync_inheritance_stale(existing, expected).each do |name|
+              remove_index(child, name: name) unless guarded.include?(name)
+            end
+          end
+
+          def sync_inheritance_unique_constraints(child, parents, prune)
+            existing = unique_constraints(child)
+            expected = {}
+
+            parents.each do |parent|
+              unique_constraints(parent).each do |item|
+                expected[sync_inheritance_name(child, parent, item.name)] ||= item
+              end
+            end
+
+            expected.each do |name, item|
+              next if existing.any? { |other| other.name == name || other.column == item.column }
+
+              add_unique_constraint(child, item.column, name: name,
+                nulls_not_distinct: item.nulls_not_distinct, deferrable: item.deferrable)
+            end
+
+            return unless prune
+            sync_inheritance_stale(existing, expected).each do |name|
+              remove_constraint(child, name)
+            end
+          end
+
+          def sync_inheritance_exclusion_constraints(child, parents, prune)
+            existing = exclusion_constraints(child)
+            expected = {}
+
+            parents.each do |parent|
+              exclusion_constraints(parent).each do |item|
+                expected[sync_inheritance_name(child, parent, item.name)] ||= item
+              end
+            end
+
+            expected.each do |name, item|
+              next if existing.any? { |other| other.name == name || sync_inheritance_exclusion?(other, item) }
+
+              add_exclusion_constraint(child, item.expression, name: name,
+                using: item.using, where: item.where, deferrable: item.deferrable)
+            end
+
+            return unless prune
+            sync_inheritance_stale(existing, expected).each do |name|
+              remove_constraint(child, name)
+            end
+          end
+
+          def sync_inheritance_foreign_keys(child, parents, prune)
+            existing = foreign_keys(child)
+            expected = {}
+
+            parents.each do |parent|
+              foreign_keys(parent).each do |item|
+                expected[sync_inheritance_name(child, parent, item.name)] ||= item
+              end
+            end
+
+            expected.each do |name, item|
+              next if existing.any? { |other| other.name == name || sync_inheritance_foreign_key?(other, item) }
+
+              options = item.options.slice(:column, :primary_key, :on_delete, :on_update, :deferrable)
+              add_foreign_key(child, item.to_table, name: name, **options)
+            end
+
+            return unless prune
+            sync_inheritance_stale(existing, expected).each do |name|
+              remove_constraint(child, name)
+            end
+          end
+
+          # Every copy is named after the marker plus a digest of where it came
+          # from and where it went, which keeps it identical across databases and
+          # always well below the identifier limit
+          def sync_inheritance_name(child, parent, source)
+            digest = OpenSSL::Digest::SHA256.hexdigest("#{child}/#{parent}/#{source}")
+            "#{SYNC_MARKER}#{digest.first(10)}"
+          end
+
+          def sync_inheritance_copy?(name)
+            name.to_s.start_with?(SYNC_MARKER)
+          end
+
+          # Copies whose source is gone from the parent, which is all that a
+          # prune is ever allowed to drop
+          def sync_inheritance_stale(existing, expected)
+            existing.filter_map do |item|
+              item.name if sync_inheritance_copy?(item.name) && !expected.key?(item.name)
+            end
+          end
+
+          # PostgreSQL names the index that backs a constraint after the
+          # constraint itself, and +indexes+ hands those back along with the
+          # regular ones. Adding the constraint recreates them, so they are only
+          # skipped when that constraint is being copied as well. Without any
+          # feature given, every one of them is listed
+          def sync_inheritance_constraint_indexes(table_name, features = nil)
+            names = []
+            names.concat(unique_constraints(table_name).map(&:name)) \
+              if features.nil? || features[:unique_constraints]
+            names.concat(exclusion_constraints(table_name).map(&:name)) \
+              if features.nil? || features[:exclusion_constraints]
+            names
+          end
+
+          def sync_inheritance_index_options(index)
+            {
+              unique: index.unique,
+              where: index.where,
+              using: index.using,
+              include: index.include,
+              nulls_not_distinct: index.nulls_not_distinct,
+              order: index.orders,
+              opclass: index.opclasses,
+            }.compact_blank
+          end
+
+          def sync_inheritance_index?(current, source)
+            current.columns == source.columns && current.unique == source.unique &&
+              current.where == source.where && current.using == source.using
+          end
+
+          def sync_inheritance_exclusion?(current, source)
+            current.expression == source.expression && current.using == source.using &&
+              current.where == source.where
+          end
+
+          def sync_inheritance_foreign_key?(current, source)
+            current.to_table == source.to_table &&
+              current.options[:column] == source.options[:column] &&
+              current.options[:primary_key] == source.options[:primary_key]
+          end
+
+          # Tells whether the primary key of the given table is the one it got
+          # from a parent, which is the only case the dumper has to describe
+          # through the +sync+ option
+          def sync_inheritance_parent_primary_key?(table_name)
+            keys = primary_keys(table_name)
+            return false if keys.empty?
+
+            parents = inherited_table_names(table_name)
+            parents.any? { |parent| primary_keys(parent) == keys }
+          end
+
+      end
+    end
+  end
+end

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

@@ -8,6 +8,23 @@ module Torque
           def force_equality?(value)
             PostgreSQL.config.predicate_builder.handle_array_attributes ? false : super
           end
+
+          private
+
+            # A label path is an Array of labels, so the regular recursion would
+            # take each of its labels as another dimension of the column. Paths
+            # are a single value to PostgreSQL, which means that the entries of
+            # the array are never a dimension of their own
+            def type_cast_array(value, method)
+              return super unless path_subtype?
+              return subtype.public_send(method, value) unless value.is_a?(::Array)
+
+              value.map { |item| subtype.public_send(method, item) }
+            end
+
+            def path_subtype?
+              PostgreSQL.config.ltree.enabled && subtype.is_a?(Ltree)
+            end
         end
 
         ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.prepend(Array)

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

@@ -2,7 +2,7 @@
 
 module Torque
   module PostgreSQL
-    class Box < Struct.new(:x1, :y1, :x2, :y2)
+    class Box < ::Struct.new(:x1, :y1, :x2, :y2)
       def points
         klass = Torque::PostgreSQL.config.geometry.point_class
         [

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

@@ -2,7 +2,7 @@
 
 module Torque
   module PostgreSQL
-    class Circle < Struct.new(:x, :y, :r)
+    class Circle < ::Struct.new(:x, :y, :r)
       alias radius r
       alias radius= r=
 

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

@@ -0,0 +1,116 @@
+# 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
+          def self.from(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/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=