torque-postgresql 4.0.1 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e1560c305d73659df33b4dcc71dd57376ab72d898ef1848e54c8aaa5689584e
-  data.tar.gz: 0fc8842730a9970f999b52c6a10feb728f16b79086b4389f114ccca12e24f5a9
+  metadata.gz: c79e4ae9bb15bd5111bdd7f99e93b2be6aeb8dbe8446005f1692b3d419a6a096
+  data.tar.gz: fc41a9e09f887d8d6d9dd3920e2bc3b2d51e3b17af48b76e875c37d7a37a992a
 SHA512:
-  metadata.gz: 9985681094dc57004a8d823f5f13d5383d965304336d1b9e4a886fa812e8b9dfca5af93504a7b46ed58e7e508fd0d3c8048d367b5b8c36f42f9dc293f2f556bf
-  data.tar.gz: 4b23fe90238cb6f0f7c424631e381c27b15bc932e69d46d68dfba9f96a39081d40b80a0ff61266ab1122c24f10242c26a1728e5e737ef847a49c403e8b3e9c88
+  metadata.gz: 7b98f253f6b1b47a1ed18a07e1850793b127847b144a0a75b61f3a96a439b6473117ab769f5a17db17820bd498a81d7adf06f73222c48020fff0b6505fa210e2
+  data.tar.gz: eeb9cbb8dfff58d3d3836e5e7f8199fbf77a7048b387dbde41de77a98ff1254784cf02f0c702d6513c4623b7724da8f70e1829e9d16be26fd0d6f55a9e8cd046

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'
@@ -32,3 +56,31 @@ end
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
+
+RBS_TEST_ENV = {
+  'RBS_TEST' => '1',
+  'RBS_TEST_TARGET' => 'Torque::PostgreSQL::*,Torque::Generators::*',
+  'RBS_TEST_SKIP' => '::Torque::PostgreSQL::Attributes::Lazy,::Torque::PostgreSQL::Adapter::OID::Range::Comparison',
+  'RBS_TEST_OPT' => '-I sig',
+  'RBS_TEST_LOGLEVEL' => ENV.fetch('RBS_TEST_LOGLEVEL', 'warn'),
+}.freeze
+
+namespace :rbs do
+  desc 'Install the third-party signatures listed in rbs_collection.yaml'
+  task :collection do
+    sh 'bundle', 'exec', 'rbs', 'collection', 'install'
+  end
+
+  desc 'Validate sig/ against the collection and the local stubs'
+  task validate: :collection do
+    sh 'bundle', 'exec', 'rbs', '-I', 'sig', 'validate', '--exit-error-on-syntax-error'
+  end
+
+  desc 'Run the spec suite with runtime type checking of every signature'
+  task test: :collection do
+    sh RBS_TEST_ENV, 'bundle', 'exec', 'rspec'
+  end
+end
+
+desc 'Validate the signatures and run the typed spec suite'
+task rbs: %w[rbs:validate rbs:test]

data/lib/generators/torque/skill_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Torque
+  module Generators
+    class SkillGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../../skills', __dir__)
+
+      desc 'Copies the torque-postgresql agent skill into .claude/skills'
+
+      def copy_skill
+        directory 'torque-postgresql', '.claude/skills/torque-postgresql'
+      end
+    end
+  end
+end

data/lib/generators/torque/templates/trigger.sql.erb

@@ -0,0 +1,3 @@
+CREATE OR REPLACE TRIGGER <%= name %>
+  BEFORE INSERT ON table_name
+  FOR EACH ROW EXECUTE FUNCTION function_name();

data/lib/generators/torque/trigger_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class TriggerGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_trigger_file create_migration_file
+    end
+  end
+end

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.
@@ -211,6 +253,15 @@ module Torque
                 WHERE 1=1 AND c.relkind IN ('v', 'm')
                   AND #{filter_by_schema.join(' AND ')};
               SQL
+            when :trigger
+              <<-SQL.squish
+                SELECT n.nspname AS schema, t.tgname AS name
+                FROM pg_trigger t
+                INNER JOIN pg_class c ON c.oid = t.tgrelid
+                INNER JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE 1=1 AND NOT t.tgisinternal
+                  AND #{filter_by_schema.join(' AND ')};
+              SQL
             end
 
           select_rows(query, 'SCHEMA')
@@ -229,6 +280,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,19 @@ module Torque
           def force_equality?(value)
             PostgreSQL.config.predicate_builder.handle_array_attributes ? false : super
           end
+
+          private
+
+            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=