chrono_model 1.2.2 → 2.0.0

data/lib/chrono_model/adapter/ddl.rb

@@ -1,225 +1,240 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/strip'
 require 'multi_json'
 
 module ChronoModel
   class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-
     module DDL
       private
-        # Create the public view and its INSTEAD OF triggers
-        #
-        def chrono_public_view_ddl(table, options = nil)
-          pk      = primary_key(table)
-          current = [TEMPORAL_SCHEMA, table].join('.')
-          history = [HISTORY_SCHEMA,  table].join('.')
 
-          options ||= chrono_metadata_for(table)
+      # Create the public view and its INSTEAD OF triggers
+      #
+      def chrono_public_view_ddl(table, options = nil)
+        pk      = primary_key(table)
+        current = "#{TEMPORAL_SCHEMA}.#{table}"
+        history = "#{HISTORY_SCHEMA}.#{table}"
 
-          # SELECT - return only current data
-          #
-          execute "DROP VIEW #{table}" if data_source_exists? table
-          execute "CREATE VIEW #{table} AS SELECT * FROM ONLY #{current}"
+        options ||= chrono_metadata_for(table)
+
+        # SELECT - return only current data
+        #
+        execute "DROP VIEW #{table}" if data_source_exists? table
+        execute "CREATE VIEW #{table} AS SELECT * FROM ONLY #{current}"
 
-          chrono_metadata_set(table, options.merge(chronomodel: VERSION))
+        chrono_metadata_set(table, options.merge(chronomodel: VERSION))
 
-          # Set default values on the view (closes #12)
-          #
-          columns(table).each do |column|
-            default = if column.default.nil?
+        # Set default values on the view (closes #12)
+        #
+        columns(table).each do |column|
+          default =
+            if column.default.nil?
               column.default_function
             else
               quote(column.default)
             end
 
-            next if column.name == pk || default.nil?
+          next if column.name == pk || default.nil?
 
-            execute "ALTER VIEW #{table} ALTER COLUMN #{quote_column_name(column.name)} SET DEFAULT #{default}"
-          end
+          execute "ALTER VIEW #{table} ALTER COLUMN #{quote_column_name(column.name)} SET DEFAULT #{default}"
+        end
 
-          columns = self.columns(table).map {|c| quote_column_name(c.name)}
-          columns.delete(quote_column_name(pk))
+        columns = self.columns(table).map { |c| quote_column_name(c.name) }
+        columns.delete(quote_column_name(pk))
 
-          fields, values = columns.join(', '), columns.map {|c| "NEW.#{c}"}.join(', ')
+        fields = columns.join(', ')
+        values = columns.map { |c| "NEW.#{c}" }.join(', ')
 
-          chrono_create_INSERT_trigger(table, pk, current, history, fields, values)
-          chrono_create_UPDATE_trigger(table, pk, current, history, fields, values, options, columns)
-          chrono_create_DELETE_trigger(table, pk, current, history)
-        end
+        chrono_create_INSERT_trigger(table, pk, current, history, fields, values)
+        chrono_create_UPDATE_trigger(table, pk, current, history, fields, values, options, columns)
+        chrono_create_DELETE_trigger(table, pk, current, history)
+      end
 
-        # Create the history table in the history schema
-        def chrono_history_table_ddl(table)
-          parent = "#{TEMPORAL_SCHEMA}.#{table}"
-          p_pkey = primary_key(parent)
+      # Create the history table in the history schema
+      def chrono_history_table_ddl(table)
+        parent = "#{TEMPORAL_SCHEMA}.#{table}"
+        p_pkey = primary_key(parent)
 
-          execute <<-SQL
+        execute <<-SQL.squish
             CREATE TABLE #{table} (
-              hid         SERIAL PRIMARY KEY,
+              hid         BIGSERIAL PRIMARY KEY,
               validity    tsrange NOT NULL,
               recorded_at timestamp NOT NULL DEFAULT timezone('UTC', now())
             ) INHERITS ( #{parent} )
-          SQL
-
-          add_history_validity_constraint(table, p_pkey)
+        SQL
 
-          chrono_create_history_indexes_for(table, p_pkey)
-        end
+        add_history_validity_constraint(table, p_pkey)
 
-        def add_history_validity_constraint(table, pkey)
-          add_timeline_consistency_constraint(table, :validity, id: pkey, on_current_schema: true)
-        end
+        chrono_create_history_indexes_for(table, p_pkey)
+      end
 
-        def remove_history_validity_constraint(table, options = {})
-          remove_timeline_consistency_constraint(table, options.merge(on_current_schema: true))
-        end
+      def add_history_validity_constraint(table, pkey)
+        add_timeline_consistency_constraint(table, :validity, id: pkey, on_current_schema: true)
+      end
 
-        # INSERT - insert data both in the temporal table and in the history one.
-        #
-        # The serial sequence is invoked manually only if the PK is NULL, to
-        # allow setting the PK to a specific value (think migration scenario).
-        #
-        def chrono_create_INSERT_trigger(table, pk, current, history, fields, values)
-          seq = serial_sequence(current, pk)
+      def remove_history_validity_constraint(table, options = {})
+        remove_timeline_consistency_constraint(table, options.merge(on_current_schema: true))
+      end
 
-          execute <<-SQL
+      # INSERT - insert data both in the temporal table and in the history one.
+      #
+      # The serial sequence is invoked manually only if the PK is NULL, to
+      # allow setting the PK to a specific value (think migration scenario).
+      #
+      def chrono_create_INSERT_trigger(table, pk, current, history, fields, values)
+        execute <<-SQL.strip_heredoc # rubocop:disable Rails/SquishedSQLHeredocs
             CREATE OR REPLACE FUNCTION chronomodel_#{table}_insert() RETURNS TRIGGER AS $$
-              BEGIN
-                IF NEW.#{pk} IS NULL THEN
-                  NEW.#{pk} := nextval('#{seq}');
-                END IF;
+                BEGIN
+                    #{insert_sequence_sql(pk, current)} INTO #{current} ( #{pk}, #{fields} )
+                    VALUES ( NEW.#{pk}, #{values} );
 
-                INSERT INTO #{current} ( #{pk}, #{fields} )
-                VALUES ( NEW.#{pk}, #{values} );
+                    INSERT INTO #{history} ( #{pk}, #{fields}, validity )
+                    VALUES ( NEW.#{pk}, #{values}, tsrange(timezone('UTC', now()), NULL) );
 
-                INSERT INTO #{history} ( #{pk}, #{fields}, validity )
-                VALUES ( NEW.#{pk}, #{values}, tsrange(timezone('UTC', now()), NULL) );
+                    RETURN NEW;
+                END;
 
-                RETURN NEW;
-              END;
             $$ LANGUAGE plpgsql;
 
             DROP TRIGGER IF EXISTS chronomodel_insert ON #{table};
 
             CREATE TRIGGER chronomodel_insert INSTEAD OF INSERT ON #{table}
-              FOR EACH ROW EXECUTE PROCEDURE chronomodel_#{table}_insert();
-          SQL
-        end
-
-        # UPDATE - set the last history entry validity to now, save the current data
-        # in a new history entry and update the temporal table with the new data.
-        #
-        # If there are no changes, this trigger suppresses redundant updates.
-        #
-        # If a row in the history with the current ID and current timestamp already
-        # exists, update it with new data. This logic makes possible to "squash"
-        # together changes made in a transaction in a single history row.
-        #
-        # If you want to disable this behaviour, set the CHRONOMODEL_NO_SQUASH
-        # environment variable. This is useful when running scenarios inside
-        # cucumber, in which everything runs in the same transaction.
+                FOR EACH ROW EXECUTE PROCEDURE chronomodel_#{table}_insert();
+        SQL
+      end
+
+      # UPDATE - set the last history entry validity to now, save the current data
+      # in a new history entry and update the temporal table with the new data.
+      #
+      # If there are no changes, this trigger suppresses redundant updates.
+      #
+      # If a row in the history with the current ID and current timestamp already
+      # exists, update it with new data. This logic makes possible to "squash"
+      # together changes made in a transaction in a single history row.
+      #
+      # If you want to disable this behaviour, set the CHRONOMODEL_NO_SQUASH
+      # environment variable. This is useful when running scenarios inside
+      # cucumber, in which everything runs in the same transaction.
+      #
+      def chrono_create_UPDATE_trigger(table, pk, current, history, fields, values, options, columns)
+        # Columns to be journaled. By default everything except updated_at (GH #7)
         #
-        def chrono_create_UPDATE_trigger(table, pk, current, history, fields, values, options, columns)
-          # Columns to be journaled. By default everything except updated_at (GH #7)
-          #
-          journal = if options[:journal]
-            options[:journal].map {|col| quote_column_name(col)}
+        journal =
+          if options[:journal]
+            options[:journal].map { |col| quote_column_name(col) }
 
           elsif options[:no_journal]
-            columns - options[:no_journal].map {|col| quote_column_name(col)}
+            columns - options[:no_journal].map { |col| quote_column_name(col) }
 
           elsif options[:full_journal]
             columns
 
           else
-            columns - [ quote_column_name('updated_at') ]
+            columns - [quote_column_name('updated_at')]
           end
 
-          journal &= columns
+        journal &= columns
 
-          execute <<-SQL
+        execute <<-SQL.strip_heredoc # rubocop:disable Rails/SquishedSQLHeredocs
             CREATE OR REPLACE FUNCTION chronomodel_#{table}_update() RETURNS TRIGGER AS $$
-              DECLARE _now timestamp;
-              DECLARE _hid integer;
-              DECLARE _old record;
-              DECLARE _new record;
-              BEGIN
-                IF OLD IS NOT DISTINCT FROM NEW THEN
-                  RETURN NULL;
-                END IF;
-
-                _old := row(#{journal.map {|c| "OLD.#{c}" }.join(', ')});
-                _new := row(#{journal.map {|c| "NEW.#{c}" }.join(', ')});
-
-                IF _old IS NOT DISTINCT FROM _new THEN
-                  UPDATE ONLY #{current} SET ( #{fields} ) = ( #{values} ) WHERE #{pk} = OLD.#{pk};
-                  RETURN NEW;
-                END IF;
-
-                _now := timezone('UTC', now());
-                _hid := NULL;
-
-                #{"SELECT hid INTO _hid FROM #{history} WHERE #{pk} = OLD.#{pk} AND lower(validity) = _now;" unless ENV['CHRONOMODEL_NO_SQUASH']}
-
-                IF _hid IS NOT NULL THEN
-                  UPDATE #{history} SET ( #{fields} ) = ( #{values} ) WHERE hid = _hid;
-                ELSE
-                  UPDATE #{history} SET validity = tsrange(lower(validity), _now)
-                  WHERE #{pk} = OLD.#{pk} AND upper_inf(validity);
-
-                  INSERT INTO #{history} ( #{pk}, #{fields}, validity )
-                       VALUES ( OLD.#{pk}, #{values}, tsrange(_now, NULL) );
-                END IF;
-
-                UPDATE ONLY #{current} SET ( #{fields} ) = ( #{values} ) WHERE #{pk} = OLD.#{pk};
-
-                RETURN NEW;
-              END;
+                DECLARE _now timestamp;
+                DECLARE _hid integer;
+                DECLARE _old record;
+                DECLARE _new record;
+                BEGIN
+                    IF OLD IS NOT DISTINCT FROM NEW THEN
+                        RETURN NULL;
+                    END IF;
+
+                    _old := row(#{journal.map { |c| "OLD.#{c}" }.join(', ')});
+                    _new := row(#{journal.map { |c| "NEW.#{c}" }.join(', ')});
+
+                    IF _old IS NOT DISTINCT FROM _new THEN
+                        UPDATE ONLY #{current} SET ( #{fields} ) = ( #{values} ) WHERE #{pk} = OLD.#{pk};
+                        RETURN NEW;
+                    END IF;
+
+                    _now := timezone('UTC', now());
+                    _hid := NULL;
+
+                    #{"SELECT hid INTO _hid FROM #{history} WHERE #{pk} = OLD.#{pk} AND lower(validity) = _now;" unless ENV['CHRONOMODEL_NO_SQUASH']}
+
+                    IF _hid IS NOT NULL THEN
+                        UPDATE #{history} SET ( #{fields} ) = ( #{values} ) WHERE hid = _hid;
+                    ELSE
+                        UPDATE #{history} SET validity = tsrange(lower(validity), _now)
+                        WHERE #{pk} = OLD.#{pk} AND upper_inf(validity);
+
+                        INSERT INTO #{history} ( #{pk}, #{fields}, validity )
+                            VALUES ( OLD.#{pk}, #{values}, tsrange(_now, NULL) );
+                    END IF;
+
+                    UPDATE ONLY #{current} SET ( #{fields} ) = ( #{values} ) WHERE #{pk} = OLD.#{pk};
+
+                    RETURN NEW;
+                END;
+
             $$ LANGUAGE plpgsql;
 
             DROP TRIGGER IF EXISTS chronomodel_update ON #{table};
 
             CREATE TRIGGER chronomodel_update INSTEAD OF UPDATE ON #{table}
-              FOR EACH ROW EXECUTE PROCEDURE chronomodel_#{table}_update();
-          SQL
-        end
-
-        # DELETE - save the current data in the history and eventually delete the
-        # data from the temporal table.
-        # The first DELETE is required to remove history for records INSERTed and
-        # DELETEd in the same transaction.
-        #
-        def chrono_create_DELETE_trigger(table, pk, current, history)
-          execute <<-SQL
+                FOR EACH ROW EXECUTE PROCEDURE chronomodel_#{table}_update();
+        SQL
+      end
+
+      # DELETE - save the current data in the history and eventually delete the
+      # data from the temporal table.
+      # The first DELETE is required to remove history for records INSERTed and
+      # DELETEd in the same transaction.
+      #
+      def chrono_create_DELETE_trigger(table, pk, current, history)
+        execute <<-SQL.strip_heredoc # rubocop:disable Rails/SquishedSQLHeredocs
             CREATE OR REPLACE FUNCTION chronomodel_#{table}_delete() RETURNS TRIGGER AS $$
-              DECLARE _now timestamp;
-              BEGIN
-                _now := timezone('UTC', now());
+                DECLARE _now timestamp;
+                BEGIN
+                    _now := timezone('UTC', now());
+
+                    DELETE FROM #{history}
+                    WHERE #{pk} = old.#{pk} AND validity = tsrange(_now, NULL);
 
-                DELETE FROM #{history}
-                WHERE #{pk} = old.#{pk} AND validity = tsrange(_now, NULL);
+                    UPDATE #{history} SET validity = tsrange(lower(validity), _now)
+                    WHERE #{pk} = old.#{pk} AND upper_inf(validity);
 
-                UPDATE #{history} SET validity = tsrange(lower(validity), _now)
-                WHERE #{pk} = old.#{pk} AND upper_inf(validity);
+                    DELETE FROM ONLY #{current}
+                    WHERE #{pk} = old.#{pk};
 
-                DELETE FROM ONLY #{current}
-                WHERE #{pk} = old.#{pk};
+                    RETURN OLD;
+                END;
 
-                RETURN OLD;
-              END;
             $$ LANGUAGE plpgsql;
 
             DROP TRIGGER IF EXISTS chronomodel_delete ON #{table};
 
             CREATE TRIGGER chronomodel_delete INSTEAD OF DELETE ON #{table}
-              FOR EACH ROW EXECUTE PROCEDURE chronomodel_#{table}_delete();
-          SQL
-        end
+                FOR EACH ROW EXECUTE PROCEDURE chronomodel_#{table}_delete();
+        SQL
+      end
 
-        def chrono_drop_trigger_functions_for(table_name)
-          %w( insert update delete ).each do |func|
-            execute "DROP FUNCTION IF EXISTS chronomodel_#{table_name}_#{func}()"
-          end
+      def chrono_drop_trigger_functions_for(table_name)
+        %w[insert update delete].each do |func|
+          execute "DROP FUNCTION IF EXISTS chronomodel_#{table_name}_#{func}()"
         end
+      end
+
+      def insert_sequence_sql(pk, current)
+        seq = pk_and_sequence_for(current)
+        return 'INSERT' if seq.blank?
+
+        <<-SQL.strip # rubocop:disable Rails/SquishedSQLHeredocs
+                    IF NEW.#{pk} IS NULL THEN
+                        NEW.#{pk} := nextval('#{seq.last}');
+                    END IF;
+
+                    INSERT
+        SQL
+      end
       # private
     end
-
   end
 end

data/lib/chrono_model/adapter/indexes.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-
     module Indexes
       # Create temporal indexes for timestamp search.
       #
@@ -23,7 +24,7 @@ module ChronoModel
           temporal_index_names(table, range, options)
 
         chrono_alter_index(table, options) do
-          execute <<-SQL
+          execute <<-SQL.squish
             CREATE INDEX #{range_idx} ON #{table} USING gist ( #{range} )
           SQL
 
@@ -39,7 +40,7 @@ module ChronoModel
         indexes = temporal_index_names(table, range, options)
 
         chrono_alter_index(table, options) do
-          indexes.each {|idx| execute "DROP INDEX #{idx}" }
+          indexes.each { |idx| execute "DROP INDEX #{idx}" }
         end
       end
 
@@ -52,7 +53,7 @@ module ChronoModel
         id   = options[:id] || primary_key(table)
 
         chrono_alter_constraint(table, options) do
-          execute <<-SQL
+          execute <<-SQL.squish
             ALTER TABLE #{table} ADD CONSTRAINT #{name}
               EXCLUDE USING gist ( #{id} WITH =, #{range} WITH && )
           SQL
@@ -63,7 +64,7 @@ module ChronoModel
         name = timeline_consistency_constraint_name(table)
 
         chrono_alter_constraint(table, options) do
-          execute <<-SQL
+          execute <<-SQL.squish
             ALTER TABLE #{table} DROP CONSTRAINT #{name}
           SQL
         end
@@ -74,121 +75,125 @@ module ChronoModel
       end
 
       private
-        # Creates indexes for a newly made history table
-        #
-        def chrono_create_history_indexes_for(table, p_pkey)
-          add_temporal_indexes table, :validity, on_current_schema: true
 
-          execute "CREATE INDEX #{table}_inherit_pkey     ON #{table} ( #{p_pkey} )"
-          execute "CREATE INDEX #{table}_recorded_at      ON #{table} ( recorded_at )"
-          execute "CREATE INDEX #{table}_instance_history ON #{table} ( #{p_pkey}, recorded_at )"
-        end
+      # Creates indexes for a newly made history table
+      #
+      def chrono_create_history_indexes_for(table, p_pkey)
+        add_temporal_indexes table, :validity, on_current_schema: true
 
-        # Rename indexes on history schema
-        #
-        def chrono_rename_history_indexes(name, new_name)
-          on_history_schema do
-            standard_index_names = %w(
-              inherit_pkey instance_history pkey
-              recorded_at timeline_consistency )
+        execute "CREATE INDEX #{table}_inherit_pkey     ON #{table} ( #{p_pkey} )"
+        execute "CREATE INDEX #{table}_recorded_at      ON #{table} ( recorded_at )"
+        execute "CREATE INDEX #{table}_instance_history ON #{table} ( #{p_pkey}, recorded_at )"
+      end
+
+      # Rename indexes on history schema
+      #
+      def chrono_rename_history_indexes(name, new_name)
+        on_history_schema do
+          standard_index_names = %w[
+            inherit_pkey instance_history pkey
+            recorded_at timeline_consistency
+          ]
 
-            old_names = temporal_index_names(name, :validity) +
-              standard_index_names.map {|i| [name, i].join('_') }
+          old_names = temporal_index_names(name, :validity) +
+                      standard_index_names.map { |i| "#{name}_#{i}" }
 
-            new_names = temporal_index_names(new_name, :validity) +
-              standard_index_names.map {|i| [new_name, i].join('_') }
+          new_names = temporal_index_names(new_name, :validity) +
+                      standard_index_names.map { |i| "#{new_name}_#{i}" }
 
-            old_names.zip(new_names).each do |old, new|
-              execute "ALTER INDEX #{old} RENAME TO #{new}"
-            end
+          old_names.zip(new_names).each do |old, new|
+            execute "ALTER INDEX #{old} RENAME TO #{new}"
           end
         end
+      end
 
-        # Rename indexes on temporal schema
-        #
-        def chrono_rename_temporal_indexes(name, new_name)
-          on_temporal_schema do
-            temporal_indexes =  indexes(new_name)
-            temporal_indexes.map(&:name).each do |old_idx_name|
-              if old_idx_name =~ /^index_#{name}_on_(?<columns>.+)/
-                new_idx_name = "index_#{new_name}_on_#{$~['columns']}"
-                execute "ALTER INDEX #{old_idx_name} RENAME TO #{new_idx_name}"
-              end
+      # Rename indexes on temporal schema
+      #
+      def chrono_rename_temporal_indexes(name, new_name)
+        on_temporal_schema do
+          temporal_indexes = indexes(new_name)
+          temporal_indexes.map(&:name).each do |old_idx_name|
+            if old_idx_name =~ /^index_#{name}_on_(?<columns>.+)/
+              new_idx_name = "index_#{new_name}_on_#{$~['columns']}"
+              execute "ALTER INDEX #{old_idx_name} RENAME TO #{new_idx_name}"
             end
           end
         end
+      end
 
-        # Copy the indexes from the temporal table to the history table
-        # if the indexes are not already created with the same name.
-        #
-        # Uniqueness is voluntarily ignored, as it doesn't make sense on
-        # history tables.
-        #
-        # Used in migrations.
-        #
-        # Ref: GitHub pull #21.
-        #
-        def chrono_copy_indexes_to_history(table_name)
-          history_indexes  = on_history_schema  { indexes(table_name) }.map(&:name)
-          temporal_indexes = on_temporal_schema { indexes(table_name) }
+      # Copy the indexes from the temporal table to the history table
+      # if the indexes are not already created with the same name.
+      #
+      # Uniqueness is voluntarily ignored, as it doesn't make sense on
+      # history tables.
+      #
+      # Used in migrations.
+      #
+      # Ref: GitHub pull #21.
+      #
+      def chrono_copy_indexes_to_history(table_name)
+        history_indexes  = on_history_schema  { indexes(table_name) }.map(&:name)
+        temporal_indexes = on_temporal_schema { indexes(table_name) }
 
-          temporal_indexes.each do |index|
-            next if history_indexes.include?(index.name)
+        temporal_indexes.each do |index|
+          next if history_indexes.include?(index.name)
 
-            on_history_schema do
-              execute %[
+          on_history_schema do
+            # index.columns is an Array for plain indexes,
+            # while it is a String for computed indexes.
+            #
+            columns = Array.wrap(index.columns).join(', ')
+
+            execute %[
                 CREATE INDEX #{index.name} ON #{table_name}
-                USING #{index.using} ( #{index.columns.join(', ')} )
+                USING #{index.using} ( #{columns} )
               ], 'Copy index from temporal to history'
-            end
           end
         end
+      end
 
-        # Returns a suitable index name on the given table and for the
-        # given range definition.
-        #
-        def temporal_index_names(table, range, options = {})
-          prefix = options[:name].presence || "index_#{table}_temporal"
-
-          # When creating computed indexes
-          #
-          # e.g. ends_on::timestamp + time '23:59:59'
-          #
-          # remove everything following the field name.
-          range = range.to_s.sub(/\W.*/, '')
-
-          [range, "lower_#{range}", "upper_#{range}"].map do |suffix|
-            [prefix, 'on', suffix].join('_')
-          end
-        end
+      # Returns a suitable index name on the given table and for the
+      # given range definition.
+      #
+      def temporal_index_names(table, range, options = {})
+        prefix = options[:name].presence || "index_#{table}_temporal"
 
-        # Generic alteration of history tables, where changes have to be
-        # propagated both on the temporal table and the history one.
+        # When creating computed indexes
         #
-        # Internally, the :on_current_schema bypasses the +is_chrono?+
-        # check, as some temporal indexes and constraints are created
-        # only on the history table, and the creation methods already
-        # run scoped into the correct schema.
+        # e.g. ends_on::timestamp + time '23:59:59'
         #
-        def chrono_alter_index(table_name, options)
-          if is_chrono?(table_name) && !options[:on_current_schema]
-            on_temporal_schema { yield }
-            on_history_schema { yield }
-          else
-            yield
-          end
-        end
+        # remove everything following the field name.
+        range = range.to_s.sub(/\W.*/, '')
 
-        def chrono_alter_constraint(table_name, options)
-          if is_chrono?(table_name) && !options[:on_current_schema]
-            on_temporal_schema { yield }
-          else
-            yield
-          end
+        [range, "lower_#{range}", "upper_#{range}"].map do |suffix|
+          "#{prefix}_on_#{suffix}"
         end
+      end
 
+      # Generic alteration of history tables, where changes have to be
+      # propagated both on the temporal table and the history one.
+      #
+      # Internally, the :on_current_schema bypasses the +is_chrono?+
+      # check, as some temporal indexes and constraints are created
+      # only on the history table, and the creation methods already
+      # run scoped into the correct schema.
+      #
+      def chrono_alter_index(table_name, options, &block)
+        if is_chrono?(table_name) && !options[:on_current_schema]
+          on_temporal_schema(&block)
+          on_history_schema(&block)
+        else
+          yield
+        end
+      end
 
+      def chrono_alter_constraint(table_name, options, &block)
+        if is_chrono?(table_name) && !options[:on_current_schema]
+          on_temporal_schema(&block)
+        else
+          yield
+        end
+      end
     end
-
   end
 end