pg_aggregates 0.2.1 → 0.2.3

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.3"
 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.3
 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
@@ -72,6 +71,8 @@ files:
 - gemfiles/rails_7.0.gemfile.lock
 - gemfiles/rails_7.1.gemfile
 - gemfiles/rails_7.1.gemfile.lock
+- gemfiles/rails_8.0.gemfile
+- gemfiles/rails_8.0.gemfile.lock
 - lib/generators/pg/aggregate/aggregate_generator.rb
 - lib/generators/pg/aggregate/templates/aggregate.sql.erb
 - lib/generators/pg/aggregate/templates/migration.rb.erb
@@ -92,7 +93,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 +107,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: []