pg_aggregates 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '06275937982acc8e3dd0948ce60f2df0b5562a5b2eed7f4664a4cdf7b93c1b07'
-  data.tar.gz: 949c40f5df0902184a5a59803535a6c0298668c458391b19e7f22126e05b90bb
+  metadata.gz: 404507e81fbfe0ea608413efa6535d34c15beae11392bd86e8c4a0f98525e815
+  data.tar.gz: 953d598b8e88883db7d60153e7bcd048efe97475cd3f72949411a4cc7d7872b7
 SHA512:
-  metadata.gz: a16c309216950f5357a906c823628f63a94d25c6b1434953fd9cfe05e07197c741c934d4650024481138966cf38a9f4c91926ac59c57eac536fe601e782a3ebb
-  data.tar.gz: 46c768fe57e3ec3cf2fe5904231100b1f17ed0f3304aee35109c46f4a92d050b9143f4bb47c02c535d607036707d7b8368f3a99c4497a8a55b40fdbf4eb3eea9
+  metadata.gz: e6091519ab8526a079af9c4adce52c596e7c7f02ddf07d41d6a506a57200120a21eb58863b212d1071aa72732d30c17aa76a8622569715001a43b6ed4b84f687
+  data.tar.gz: 1df224a0da63cb50de1c435eb1a3a4c3d62e48a0efbe9deb92f8d1edbc4adeecb44745f29766368a8fe522319966224e2f01c3d5b260cdde04a93ec12868f8f5

data/.ruby-version

@@ -1 +1 @@
-3.3.5
+3.4.3

data/gemfiles/rails_6.1.gemfile

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 # This file was generated by Appraisal
 
 source "https://rubygems.org"
 
+gem "activerecord", "~> 6.1.0"
 gem "ammeter"
 gem "appraisal"
 gem "base64"
@@ -11,12 +14,11 @@ gem "drb"
 gem "gem-release"
 gem "logger"
 gem "mutex_m"
+gem "railties", "~> 6.1.0"
 gem "rake"
 gem "rspec"
 gem "rubocop-mhenrixon"
 gem "rubocop-rake"
 gem "rubocop-rspec"
-gem "activerecord", "~> 6.1.0"
-gem "railties", "~> 6.1.0"
 
 gemspec path: "../"

data/gemfiles/rails_7.0.gemfile

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 # This file was generated by Appraisal
 
 source "https://rubygems.org"
 
+gem "activerecord", "~> 7.0.0"
 gem "ammeter"
 gem "appraisal"
 gem "base64"
@@ -11,12 +14,11 @@ gem "drb"
 gem "gem-release"
 gem "logger"
 gem "mutex_m"
+gem "railties", "~> 7.0.0"
 gem "rake"
 gem "rspec"
 gem "rubocop-mhenrixon"
 gem "rubocop-rake"
 gem "rubocop-rspec"
-gem "activerecord", "~> 7.0.0"
-gem "railties", "~> 7.0.0"
 
 gemspec path: "../"

data/gemfiles/rails_7.1.gemfile

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 # This file was generated by Appraisal
 
 source "https://rubygems.org"
 
+gem "activerecord", "~> 7.1.0"
 gem "ammeter"
 gem "appraisal"
 gem "base64"
@@ -11,12 +14,11 @@ gem "drb"
 gem "gem-release"
 gem "logger"
 gem "mutex_m"
+gem "railties", "~> 7.1.0"
 gem "rake"
 gem "rspec"
 gem "rubocop-mhenrixon"
 gem "rubocop-rake"
 gem "rubocop-rspec"
-gem "activerecord", "~> 7.1.0"
-gem "railties", "~> 7.1.0"
 
 gemspec path: "../"

data/lib/pg_aggregates/railtie.rb

@@ -2,11 +2,9 @@
 
 module PgAggregates
   class Railtie < Rails::Railtie
-    initializer "postgres_aggregates.load" do
+    initializer "pg_aggregates.load", before: "fx.load" do
       ActiveSupport.on_load(:active_record) do
-        ActiveRecord::ConnectionAdapters::AbstractAdapter.include PgAggregates::SchemaStatements
-        ActiveRecord::Migration::CommandRecorder.include PgAggregates::CommandRecorder
-        ActiveRecord::SchemaDumper.prepend PgAggregates::SchemaDumper
+        PgAggregates.load
       end
     end
   end

data/lib/pg_aggregates/schema_dumper.rb

@@ -1,50 +1,90 @@
 # frozen_string_literal: true
 
+require "ostruct"
+
 module PgAggregates
   module SchemaDumper
-    def tables(stream)
-      super
+    # Define a Struct for aggregate information
+    AggregateDefinition = Struct.new(:name, :definition)
 
-      # First dump aggregates
+    # Override the tables method to inject aggregate dumping *after* functions (handled by fx)
+    # but *before* tables.
+    def tables(stream)
+      # Dump custom aggregates first
       dump_custom_aggregates(stream)
-      stream.puts
+
+      stream.puts # Add a newline for separation before tables
+
+      # Call the next implementation (likely fx's tables or Rails' tables)
+      super
     end
 
     private
 
     def dump_custom_aggregates(stream)
-      # Group all versions of each aggregate
-      aggregate_versions = {}
-
-      Dir.glob(Rails.root.join("db/aggregates/*_v*.sql").to_s).each do |file|
-        file_version = FileVersion.new(file)
-        aggregate_versions[file_version.name] ||= []
-        aggregate_versions[file_version.name] << file_version
-      end
+      aggregates = dumpable_aggregates_in_database
 
-      return if aggregate_versions.empty?
+      return if aggregates.empty?
 
       stream.puts "  # These are custom PostgreSQL aggregates that were defined"
 
-      # For each aggregate, use the latest version
-      latest_versions = aggregate_versions.transform_values do |versions|
-        versions.max_by(&:version)
-      end
-
       # Sort by name to ensure consistent ordering
-      latest_versions.keys.sort.each do |aggregate_name|
-        file_version = latest_versions[aggregate_name]
+      aggregates.sort_by(&:name).each do |aggregate|
+        stream.puts <<~AGG
+            create_aggregate "#{aggregate.name}", sql_definition: <<-SQL
+          #{aggregate.definition}
+            SQL
+
+        AGG
+      end
+    end
 
-        # Add a comment showing the version history
-        all_versions = aggregate_versions[aggregate_name].map(&:version).sort
-        version_comment = all_versions.size > 1 ? " -- versions: #{all_versions.join(", ")}" : ""
+    # Fetches all aggregate functions from the database
+    def dumpable_aggregates_in_database
+      @dumpable_aggregates_in_database ||= begin
+        # SQL query to fetch aggregate functions from PostgreSQL
+        # This query gets the aggregate name and constructs the CREATE AGGREGATE statement
+        sql = <<~SQL
+          SELECT
+            p.proname AS name,
+            format(
+              'CREATE AGGREGATE %s(%s) (%s);',
+              p.proname,
+              pg_get_function_arguments(p.oid),
+              array_to_string(array_agg(format('%s = %s', option_name, option_value)), E',\n    ')
+            ) AS definition
+          FROM pg_proc p
+          JOIN pg_namespace n ON p.pronamespace = n.oid
+          JOIN pg_aggregate a ON a.aggfnoid = p.oid
+          JOIN LATERAL (
+            SELECT 'sfunc' AS option_name, p2.proname::text AS option_value
+            FROM pg_proc p2
+            WHERE p2.oid = a.aggtransfn
+            UNION ALL
+            SELECT 'stype', format_type(a.aggtranstype, NULL)
+            UNION ALL
+            SELECT 'finalfunc', p3.proname::text
+            FROM pg_proc p3
+            WHERE p3.oid = a.aggfinalfn AND a.aggfinalfn != 0
+            UNION ALL
+            SELECT 'initcond', quote_literal(a.agginitval)
+            WHERE a.agginitval IS NOT NULL
+          ) options ON true
+          WHERE n.nspname = 'public'
+          GROUP BY p.proname, p.oid
+          ORDER BY p.proname;
+        SQL
 
-        stream.puts <<-AGG
-  create_aggregate "#{aggregate_name}", sql_definition: <<-SQL#{version_comment}
-    #{file_version.sql_definition}
-  SQL
+        # Get the appropriate connection
+        connection = ActiveRecord::Base.connection
 
-        AGG
+        # Execute the query and transform results into aggregate objects
+        connection.execute(sql).map do |result|
+          AggregateDefinition.new(
+            result["name"],
+            result["definition"].strip
+          )
+        end
       end
     end
   end

data/lib/pg_aggregates/schema_statements.rb

@@ -2,9 +2,18 @@
 
 module PgAggregates
   module SchemaStatements
+    # Reserved words to skip when checking function dependencies
+    RESERVED_WORDS = ["public"].freeze
+
     def create_aggregate(name, version: nil, sql_definition: nil)
       raise ArgumentError, "Must provide either sql_definition or version" if sql_definition.nil? && version.nil?
 
+      # First, check if the function already exists to avoid duplicate creation attempts
+      return if aggregate_exists?(name)
+
+      # Check if dependent functions exist before attempting to create
+      check_dependent_functions(sql_definition || read_aggregate_definition(name, version))
+
       if sql_definition
         execute sql_definition
       else
@@ -18,6 +27,14 @@ module PgAggregates
 
         execute aggregate_definition.to_sql
       end
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless /function .* does not exist/.match?(e.message)
+
+      puts "WARNING: Failed to create aggregate #{name} because a required function does not exist."
+      puts "         This could indicate a dependency ordering issue."
+      puts "         Error: #{e.message}"
+
+      raise
     end
 
     def drop_aggregate(name, *arg_types, force: false)
@@ -25,5 +42,59 @@ module PgAggregates
       force_clause = force ? " CASCADE" : ""
       execute "DROP AGGREGATE IF EXISTS #{name}#{arg_types_sql}#{force_clause}"
     end
+
+    private
+
+    def aggregate_exists?(name)
+      sql = <<-SQL
+        SELECT 1
+        FROM pg_catalog.pg_proc p
+        JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+        WHERE p.proname = '#{name}'
+        AND p.prokind = 'a'
+      SQL
+
+      result = execute(sql)
+      result.any?
+    rescue StandardError
+      false
+    end
+
+    def read_aggregate_definition(name, version)
+      aggregate_definition = PgAggregates::AggregateDefinition.new(name, version: version)
+      File.read(aggregate_definition.path) if File.exist?(aggregate_definition.path)
+    end
+
+    def check_dependent_functions(sql_definition)
+      return unless sql_definition
+
+      # Extract function names mentioned in the aggregate definition
+      # Be careful to extract only the function name, not schema qualifiers
+      function_matches = sql_definition.scan(/sfunc\s*=\s*['"]?(?:(?:[a-zA-Z0-9_]+\.)?([a-zA-Z0-9_]+))['"]?/i)
+      function_names = function_matches.flatten.compact.uniq
+
+      # For each referenced function, check if it exists
+      function_names.each do |function_name|
+        # Skip if function_name is empty or a reserved word
+        next if function_name.nil? || function_name.empty? || RESERVED_WORDS.include?(function_name.downcase)
+
+        check_sql = <<-SQL
+          SELECT 1#{" "}
+          FROM pg_catalog.pg_proc p
+          JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+          WHERE p.proname = '#{function_name}'
+          AND n.nspname = 'public'
+        SQL
+
+        result = execute(check_sql)
+        unless result.any?
+          puts "WARNING: Aggregate depends on function '#{function_name}' which does not exist"
+          puts "         This will likely fail. Create the function first."
+        end
+      end
+    rescue StandardError => e
+      # Log the error but continue
+      puts "WARNING: Error checking function dependencies: #{e.message}"
+    end
   end
 end

data/lib/pg_aggregates/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgAggregates
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/lib/pg_aggregates.rb

@@ -10,11 +10,27 @@ require_relative "pg_aggregates/schema_dumper"
 require_relative "pg_aggregates/railtie"
 
 module PgAggregates
+  module_function
+
   class Error < StandardError; end
 
-  class << self
-    def database
-      ActiveRecord::Base.connection
-    end
+  def load
+    # This is crucial - we must ensure proper load order:
+    # 1. extensions
+    # 2. types
+    # 3. functions
+    # 4. aggregates
+    # 5. tables
+
+    # Add schema statements and command recorder
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.include PgAggregates::SchemaStatements
+    ActiveRecord::Migration::CommandRecorder.include PgAggregates::CommandRecorder
+
+    # Hook into the schema dumper, with dependency awareness
+    ActiveRecord::SchemaDumper.prepend PgAggregates::SchemaDumper
+  end
+
+  def database
+    ActiveRecord::Base.connection
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pg_aggregates
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - mhenrixon
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -92,7 +91,6 @@ metadata:
   source_code_uri: https://github.com/mhenrixon/pg_aggregates
   changelog_uri: https://github.com/mhenrixon/pg_aggregates/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -107,8 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Rails integration for PostgreSQL aggregate functions
 test_files: []