torque-postgresql 3.4.1 → 4.0.0

data/lib/torque/postgresql/relation/merger.rb

@@ -12,6 +12,7 @@ module Torque
           merge_distinct_on
           merge_auxiliary_statements
           merge_inheritance
+          merge_buckets
 
           relation
         end
@@ -26,12 +27,15 @@ module Torque
 
           # Merge distinct on columns
           def merge_distinct_on
+            return unless relation.is_a?(Relation::DistinctOn)
             return if other.distinct_on_values.blank?
+
             relation.distinct_on_values += other.distinct_on_values
           end
 
           # Merge auxiliary statements activated by +with+
           def merge_auxiliary_statements
+            return unless relation.is_a?(Relation::AuxiliaryStatement)
             return if other.auxiliary_statements_values.blank?
 
             current = relation.auxiliary_statements_values.map{ |cte| cte.class }
@@ -44,14 +48,24 @@ module Torque
 
           # Merge settings related to inheritance tables
           def merge_inheritance
+            return unless relation.is_a?(Relation::Inheritance)
+
             relation.itself_only_value = true if other.itself_only_value.present?
 
-            if other.cast_records_value.present?
-              relation.cast_records_value += other.cast_records_value
-              relation.cast_records_value.uniq!
+            if other.cast_records_values.present?
+              relation.cast_records_values += other.cast_records_values
+              relation.cast_records_values.uniq!
             end
           end
 
+          # Merge settings related to buckets
+          def merge_buckets
+            return unless relation.is_a?(Relation::Buckets)
+            return if other.buckets_value.blank?
+
+            relation.buckets_value = other.buckets_value
+          end
+
       end
 
       ActiveRecord::Relation::Merger.prepend Merger

data/lib/torque/postgresql/relation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'relation/distinct_on'
-require_relative 'relation/auxiliary_statement'
 require_relative 'relation/inheritance'
 
 require_relative 'relation/merger'
@@ -12,19 +11,27 @@ module Torque
       extend ActiveSupport::Concern
 
       include DistinctOn
-      include AuxiliaryStatement
       include Inheritance
 
-      SINGLE_VALUE_METHODS = [:itself_only]
-      MULTI_VALUE_METHODS = [:distinct_on, :auxiliary_statements, :cast_records, :select_extra]
+      SINGLE_VALUE_METHODS = %i[itself_only buckets]
+      MULTI_VALUE_METHODS = %i[
+        select_extra distinct_on auxiliary_statements cast_records
+      ]
+
       VALUE_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
+      FROZEN_EMPTY_ARRAY = ::ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
 
       ARColumn = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Column
 
       # :nodoc:
-      def select_extra_values; get_value(:select_extra); end
+      def select_extra_values
+        @values.fetch(:select_extra, FROZEN_EMPTY_ARRAY)
+      end
       # :nodoc:
-      def select_extra_values=(value); set_value(:select_extra, value); end
+      def select_extra_values=(value)
+        assert_modifiable!
+        @values[:select_extra] = value
+      end
 
       # Resolve column name when calculating models, allowing the column name to
       # be more complex while keeping the query selection quality
@@ -92,22 +99,7 @@ module Torque
           arel
         end
 
-        # Compatibility method with 5.0
-        unless ActiveRecord::Relation.method_defined?(:get_value)
-          def get_value(name)
-            @values[name] || ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
-          end
-        end
-
-        # Compatibility method with 5.0
-        unless ActiveRecord::Relation.method_defined?(:set_value)
-          def set_value(name, value)
-            assert_mutability! if respond_to?(:assert_mutability!)
-            @values[name] = value
-          end
-        end
-
-      module ClassMethods
+      class_methods do
         # Easy and storable way to access the name used to get the record table
         # name when using inheritance tables
         def _record_class_attribute
@@ -115,7 +107,7 @@ module Torque
             .inheritance.record_class_column_name.to_sym
         end
 
-        # Easy and storable way to access the name used to get the indicater of
+        # Easy and storable way to access the name used to get the indicate of
         # auto casting inherited records
         def _auto_cast_attribute
           @@auto_cast ||= Torque::PostgreSQL.config
@@ -135,29 +127,23 @@ module Torque
         end
 
         # Allow extra keyword arguments to be sent to +InsertAll+
-        if Torque::PostgreSQL::AR720
-          def upsert_all(attributes, **xargs)
-            xargs = xargs.reverse_merge(on_duplicate: :update)
-            ::ActiveRecord::InsertAll.execute(self, attributes, **xargs)
-          end
+        def upsert_all(attributes, **xargs)
+          xargs = xargs.reverse_merge(on_duplicate: :update)
+          ::ActiveRecord::InsertAll.execute(self, attributes, **xargs)
         end
       end
     end
 
-    # Include the methos here provided and then change the constants to ensure
+    # Include the methods here provided and then change the constants to ensure
     # the operation of ActiveRecord Relation
     ActiveRecord::Relation.include Relation
     ActiveRecord::Relation.prepend Relation::Initializer
 
-    warn_level = $VERBOSE
-    $VERBOSE = nil
-
-    ActiveRecord::Relation::SINGLE_VALUE_METHODS       += Relation::SINGLE_VALUE_METHODS
-    ActiveRecord::Relation::MULTI_VALUE_METHODS        += Relation::MULTI_VALUE_METHODS
-    ActiveRecord::Relation::VALUE_METHODS              += Relation::VALUE_METHODS
-    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += %i[cast_records itself_only
-      distinct_on auxiliary_statements]
+    ActiveRecord::Relation::SINGLE_VALUE_METHODS.concat(Relation::SINGLE_VALUE_METHODS)
+    ActiveRecord::Relation::MULTI_VALUE_METHODS.concat(Relation::MULTI_VALUE_METHODS)
+    ActiveRecord::Relation::VALUE_METHODS.concat(Relation::VALUE_METHODS)
+    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES.merge(%i[cast_records itself_only
+      distinct_on auxiliary_statements buckets])
 
-    $VERBOSE = warn_level
   end
 end

data/lib/torque/postgresql/schema_cache.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 require 'torque/postgresql/schema_cache/inheritance'
-
-if Torque::PostgreSQL::AR710
-  require 'torque/postgresql/schema_cache/schema_reflection'
-  require 'torque/postgresql/schema_cache/bound_schema_reflection'
-end
+require 'torque/postgresql/schema_cache/schema_reflection'
+require 'torque/postgresql/schema_cache/bound_schema_reflection'
 
 module Torque
   module PostgreSQL
@@ -73,7 +70,7 @@ module Torque
       end
 
       def clear_data_source_cache!(connection_or_name, name = connection_or_name) # :nodoc:
-        Torque::PostgreSQL::AR710 ? super : super(name)
+        super
         @data_sources_model_names.delete name
         @inheritance_dependencies.delete name
         @inheritance_associations.delete name
@@ -130,8 +127,7 @@ module Torque
         def reload_inheritance_data!(source)
           return if @inheritance_loaded
 
-          method_name = Torque::PostgreSQL::AR720 ? :with_connection : :then
-          source.public_send(method_name) do |connection|
+          source.with_connection do |connection|
             @inheritance_dependencies = connection.inherited_tables
             @inheritance_associations = generate_associations
             @inheritance_loaded = true
@@ -145,14 +141,12 @@ module Torque
         end
 
         # Use this method to also load any irregular model name
-        method_name = Torque::PostgreSQL::AR720 ? :add_all : :prepare_data_sources
-        define_method(method_name) do |source = nil|
-          Torque::PostgreSQL::AR710 ? super(source) : super()
+        def add_all(source = nil)
+          super
 
           data_sources = source.present? ? tables_to_cache(source) : @data_sources.keys
           @data_sources_model_names = prepare_irregular_models(data_sources)
         end
-
     end
 
     ActiveRecord::ConnectionAdapters::SchemaCache.prepend SchemaCache

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.4.1'
+    VERSION = '4.0.0'
   end
 end

data/lib/torque/postgresql/versioned_commands/command_migration.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Migration
+        def initialize(*args)
+          @command = args.pop
+          super(*args)
+        end
+
+        # Prepare the description based on the direction
+        def migrate(direction)
+          @description = description_for(direction)
+          super
+        end
+
+        # Uses the command to execute the proper action
+        def exec_migration(conn, direction)
+          @connection = conn
+          direction == :up ? @command.up : @command.down
+        ensure
+          @connection = nil
+          @execution_strategy = nil
+        end
+
+        # Better formatting of the output
+        def announce(message)
+          action, result = @description
+
+          title = [
+            @command.type.capitalize,
+            @command.object_name,
+            "v#{@command.op_version}"
+          ].join(' ')
+
+          timing = message.split(' ', 2).second
+          action = "#{result} #{timing}" if timing.present?
+          text = "#{@command.version} #{title}: #{action}"
+          length = [0, 75 - text.length].max
+
+          write "== %s %s" % [text, "=" * length]
+        end
+
+        # Produces a nice description of what is being done
+        def description_for(direction)
+          base = @command.op.chomp('e') if direction == :up
+          base ||=
+            case @command.op
+            when 'create' then 'dropp'
+            when 'update' then 'revert'
+            when 'remove' then 're-creat'
+            end
+
+          ["#{base}ing", "#{base}ed"]
+        end
+
+        # Print the command and then execute it
+        def execute(command)
+          write "-- #{command.gsub(/(?<!\A)^/, '   ').gsub(/[\s\n]*\z/, '')}"
+          execution_strategy.execute(command)
+        end
+      end
+
+      CommandMigration = Struct.new(*%i[filename version op type object_name op_version scope]) do
+        delegate :execute, to: '@migration'
+
+        def initialize(filename, *args)
+          super(File.expand_path(filename), *args)
+          @migration = nil
+        end
+
+        # Rails uses this to avoid duplicate migrations
+        def name
+          "#{op}_#{type}_#{object_name}_v#{op_version}"
+        end
+
+        # There is no way to setup this, so it is always false
+        def disable_ddl_transaction
+          false
+        end
+
+        # Down is more complicated, then this just starts separating the logic
+        def migrate(direction)
+          @migration = ActiveRecord::Migration.allocate
+          @migration.extend(Migration)
+          @migration.send(:initialize, name, version, self)
+          @migration.migrate(direction)
+        ensure
+          @migration = nil
+        end
+
+        # Simply executes the underlying command
+        def up
+          content = File.read(filename)
+          VersionedCommands.validate!(type, content, object_name)
+          execute content
+        end
+
+        # Find the previous command and executes it
+        def down
+          return drop if op_version == 1
+          dirs = @migration.pool.migrations_paths
+          version = op_version - (op == 'remove' ? 0 : 1)
+          execute VersionedCommands.fetch_command(dirs, type, object_name, version)
+        end
+
+        # Drops the type created
+        def drop
+          method_name = :"drop_#{type}"
+          return send(method_name) if VersionedCommands.valid_type?(type)
+          raise ArgumentError, "Unknown versioned command type: #{type}"
+        end
+
+        private
+
+          # Drop all functions all at once
+          def drop_function
+            definitions = File.read(filename).scan(Regexp.new([
+              "FUNCTION\\s+#{NAME_MATCH}",
+              '\s*(\([_a-z0-9 ,]*\))?',
+            ].join, 'mi'))
+
+            functions = definitions.map(&:join).join(', ')
+            execute "DROP FUNCTION #{functions};"
+          end
+
+          # Drop the type
+          def drop_type
+            name = File.read(filename).scan(Regexp.new("TYPE\\s+#{NAME_MATCH}", 'mi'))
+            execute "DROP TYPE #{name.first.first};"
+          end
+
+          # Drop view or materialized view
+          def drop_view
+            mat, name = File.read(filename).scan(Regexp.new([
+              '(MATERIALIZED)?\s+(?:RECURSIVE\s+)?',
+              "VIEW\\s+#{NAME_MATCH}",
+            ].join, 'mi')).first
+
+            execute "DROP#{' MATERIALIZED' if mat.present?} VIEW #{name};"
+          end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+require 'rails/generators/active_record/migration'
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Generator
+        TEMPLATES_PATH = '../../../generators/torque/templates'
+
+        attr_reader :file_name
+
+        def self.included(base)
+          type = base.name.demodulize.chomp('Generator').underscore
+
+          base.send(:source_root, File.expand_path(TEMPLATES_PATH, __dir__))
+          base.include(ActiveRecord::Generators::Migration)
+
+          base.instance_variable_set(:@type, type)
+          base.instance_variable_set(:@desc, <<~DESC.squish)
+            Generates a migration for creating, updating, or removing a #{type}.
+          DESC
+
+          base.class_option :operation, type: :string, aliases: %i(--op),
+            desc: 'The name for the operation'
+
+          base.argument :name, type: :string,
+            desc: "The name of the #{type}"
+        end
+
+        def type
+          self.class.instance_variable_get(:@type)
+        end
+
+        def create_migration_file
+          version = count_object_entries
+          operation = options[:operation] || (version == 0 ? 'create' : 'update')
+          @file_name = "#{operation}_#{type}_#{name.underscore}_v#{version + 1}"
+
+          validate_file_name!
+          migration_template "#{type}.sql.erb", File.join(db_migrate_path, "#{file_name}.sql")
+        end
+
+        def count_object_entries
+          Dir.glob("#{db_migrate_path}/*_#{type}_#{name.underscore}_v*.sql").size
+        end
+
+        def validate_file_name!
+          unless /^[_a-z0-9]+$/.match?(file_name)
+            raise ActiveRecord::IllegalMigrationNameError.new(file_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/migration_context.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    class IllegalCommandTypeError < ActiveRecord::MigrationError
+      def initialize(file)
+        super(<<~MSG.squish)
+          Illegal name for command file '#{file}'. Commands are more strict and require
+          the version, one of create, update, or remove, type of object, name
+          and operation version to be present in the filename.
+          (e.g. 20250101010101_create_function_my_function_v1.sql)
+        MSG
+      end
+    end
+
+    module VersionedCommands
+      module MigrationContext
+        InvalidMigrationTimestampError = ActiveRecord::InvalidMigrationTimestampError
+        PGAdapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+
+        def migrations
+          return super unless running_for_pg?
+
+          commands = command_files.map do |file|
+            version, op, type, name, op_version, scope = parse_command_filename(file)
+            raise IllegalCommandTypeError.new(file) unless version
+            if validate_timestamp? && !valid_migration_timestamp?(version)
+              raise InvalidMigrationTimestampError.new(version, [op, type, name, op_version].join('_'))
+            end
+
+            version = version.to_i
+            CommandMigration.new(file, version, op, type, name, op_version.to_i, scope)
+          end
+
+          super.concat(commands).sort_by(&:version)
+        end
+
+        def migrations_status
+          return super unless running_for_pg?
+          db_list = schema_migration.normalized_versions
+
+          commands = command_files.map do |file|
+            version, op, type, name, op_version, scope = parse_command_filename(file)
+            raise IllegalCommandTypeError.new(file) unless version
+            if validate_timestamp? && !valid_migration_timestamp?(version)
+              raise InvalidMigrationTimestampError.new(version, [op, type, name, op_version].join('_'))
+            end
+
+            version = schema_migration.normalize_migration_number(version)
+            status = db_list.delete(version) ? "up" : "down"
+            [status, version, "#{op.capitalize} #{type.capitalize} #{name}#{scope} (v#{op_version})"]
+          end
+
+          (commands + super).uniq(&:second).sort_by(&:second)
+        end
+
+        def migration_commands
+          migrations.select { |m| m.is_a?(VersionedCommands::CommandMigration) }
+        end
+
+        private
+
+          # Checks if the current migration context is running for PostgreSQL
+          def running_for_pg?
+            connection_pool.db_config.adapter_class <= PGAdapter
+          end
+
+          # Get the list of all versioned command files
+          def command_files
+            paths = Array(migrations_paths)
+            Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.sql" }]
+          end
+
+          # Commands are more strict with the filename format
+          def parse_command_filename(filename)
+            File.basename(filename).scan(VersionedCommands.filename_regexp).first
+          end
+      end
+
+      ActiveRecord::MigrationContext.prepend(MigrationContext)
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/migrator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Migrator
+        def execute_migration_in_transaction(migration)
+          @versioned_command = versioned_command?(migration) && migration
+          super
+        ensure
+          @versioned_command = false
+        end
+
+        def record_version_state_after_migrating(version)
+          return super if (command = @versioned_command) == false
+
+          @versioned_table ||= VersionedCommands::SchemaTable.new(connection.pool)
+          @versioned_counter ||= @versioned_table.count
+
+          if down?
+            @versioned_counter -= 1
+            @versioned_table.delete_version(command)
+            @versioned_table.drop_table if @versioned_counter.zero?
+          else
+            @versioned_table.create_table if @versioned_counter.zero?
+            @versioned_table.create_version(command)
+            @versioned_counter += 1
+          end
+        end
+
+        def versioned_command?(migration)
+          migration.is_a?(VersionedCommands::CommandMigration)
+        end
+      end
+
+      ActiveRecord::Migrator.prepend(Migrator)
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/schema_table.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      class SchemaTable
+        attr_reader :arel_table
+
+        def initialize(pool)
+          @pool = pool
+          @arel_table = ::Arel::Table.new(table_name)
+        end
+
+        def create_version(command)
+          im = ::Arel::InsertManager.new(arel_table)
+          im.insert(
+            arel_table[primary_key] => command.version,
+            arel_table['type'] => command.type,
+            arel_table['object_name'] => command.object_name,
+          )
+
+          @pool.with_connection do |connection|
+            connection.insert(im, "#{name} Create", primary_key, command.version)
+          end
+        end
+
+        def delete_version(command)
+          dm = ::Arel::DeleteManager.new(arel_table)
+          dm.wheres = [arel_table[primary_key].eq(command.version.to_s)]
+
+          @pool.with_connection do |connection|
+            connection.delete(dm, "#{name} Destroy")
+          end
+        end
+
+        def primary_key
+          'version'
+        end
+
+        def name
+          'Torque::PostgreSQL::VersionedCommand'
+        end
+
+        def table_name
+          [
+            ActiveRecord::Base.table_name_prefix,
+            PostgreSQL.config.versioned_commands.table_name,
+            ActiveRecord::Base.table_name_suffix,
+          ].join
+        end
+
+        def create_table
+          @pool.with_connection do |connection|
+            return if connection.table_exists?(table_name)
+
+            parent = @pool.schema_migration.table_name
+            connection.create_table(table_name, inherits: parent) do |t|
+              t.string :type, null: false, index: true
+              t.string :object_name, null: false, index: true
+            end
+          end
+        end
+
+        def drop_table
+          @pool.with_connection do |connection|
+            connection.drop_table table_name, if_exists: true
+          end
+        end
+
+        def count
+          return 0 unless table_exists?
+
+          sm = ::Arel::SelectManager.new(arel_table)
+          sm.project(*FN.count(::Arel.star))
+
+          @pool.with_connection do |connection|
+            connection.select_value(sm, "#{self.class} Count")
+          end
+        end
+
+        def table_exists?
+          @pool.with_connection { |connection| connection.data_source_exists?(table_name) }
+        end
+
+        def versions_of(type)
+          return [] unless table_exists?
+
+          sm = ::Arel::SelectManager.new(arel_table)
+          sm.project(arel_table['object_name'], FN.count(::Arel.star).as('version'))
+          sm.where(arel_table['type'].eq(type.to_s))
+          sm.group(arel_table['object_name'])
+          sm.order(arel_table['object_name'].asc)
+
+          @pool.with_connection do |connection|
+            connection.select_rows(sm, "#{name} Load")
+          end
+        end
+      end
+    end
+  end
+end