chrono_model 0.4.0 → 0.5.0.beta

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    chrono_model (0.4.0)
+    chrono_model (0.5.0.beta)
       activerecord (~> 3.2)
       pg
 

data/README.md

@@ -13,9 +13,11 @@ having to deal with it.
 
 The application model is backed by an updatable view that behaves exactly like a plain table, while
 behind the scenes the database redirects the queries to concrete tables using
-[the rule system](http://www.postgresql.org/docs/9.0/static/rules-update.html).
+[the rule system](http://www.postgresql.org/docs/9.0/static/rules-update.html) for most of the cases,
+and using an `AFTER FOR EACH ROW` trigger only for the `INSERT` case on tables
+having a `SERIAL` primary key.
 
-Current data is hold in a table in the `current` [schema](http://www.postgresql.org/docs/9.0/static/ddl-schemas.html),
+Current data is hold in a table in the `temporal` [schema](http://www.postgresql.org/docs/9.0/static/ddl-schemas.html),
 while history in hold in another table in the `history` schema. The latter
 [inherits](http://www.postgresql.org/docs/9.0/static/ddl-inherit.html) from the former, to get
 automated schema updates for free. Partitioning of history is even possible but not implemented
@@ -25,20 +27,19 @@ The updatable view is created in the default `public` schema, making it visible
 
 All Active Record schema migration statements are decorated with code that handles the temporal
 structure by e.g. keeping the view rules in sync or dropping/recreating it when required by your
-migrations. A schema dumper is available as well.
+migrations.
 
 Data extraction at a single point in time and even `JOIN`s between temporal and non-temporal data
-is implemented using
-[Common Table Expressions](http://www.postgresql.org/docs/9.0/static/queries-with.html)
-(WITH queries) and a `WHERE date >= valid_from AND date < valid_to` clause, generated automatically
-by the provided `TimeMachine` module to be included in your models.
+is implemented using sub-selects and a `WHERE` generated by the provided `TimeMachine` module to
+be included in your models.
 
-Optimal temporal timestamps indexing is provided for both PostgreSQL 9.0 and 9.1 query planners.
+The `WHERE` is optimized using a spatial GiST index in which time is represented represented by
+boxes and the filtering is done using the overlapping (`&&`) geometry operator.
 
 All timestamps are (forcibly) stored in the UTC time zone, bypassing the `AR::Base.config.default_timezone`
 setting.
 
-See  [README.sql](https://github.com/ifad/chronomodel/blob/master/README.sql) for the plain SQL
+See [README.sql](https://github.com/ifad/chronomodel/blob/master/README.sql) for the plain SQL
 defining this temporal schema for a single table.
 
 
@@ -121,9 +122,17 @@ will make an `as_of` class method available to your model. E.g.:
 
 Will execute:
 
-    WITH countries AS (
-      SELECT * FROM history.countries WHERE #{1.year.ago.utc} >= valid_from AND #{1.year.ago.utc} < valid_to
-    ) SELECT * FROM countries
+    SELECT "countries".* FROM (
+      SELECT "history"."countries".* FROM "history"."countries"
+      WHERE box(
+        point( date_part( 'epoch', '#{1.year.ago.utc}'::timestamp ), 0 ),
+        point( date_part( 'epoch', '#{1.year.ago.utc}'::timestamp ), 0 )
+      ) &&
+      box(
+        point( date_part( 'epoch', "history"."addresses"."valid_from" ), 0 ),
+        point( date_part( 'epoch', "history"."addresses"."valid_to"   ), 0 ),
+      )
+    ) AS "countries"
 
 This work on associations using temporal extensions as well:
 
@@ -131,25 +140,32 @@ This work on associations using temporal extensions as well:
 
 Will execute:
 
-    WITH countries AS (
-      SELECT * FROM history.countries WHERE #{1.year.ago.utc} >= valid_from AND #{1.year.ago.utc} < valid_to
-    ) SELECT * FROM countries LIMIT 1
+    # ... countries history query ...
+    LIMIT 1
+
+    SELECT * FROM  (
+      SELECT "history"."compositions".* FROM "history"."compositions"
+      WHERE box(
+        point( date_part( 'epoch', '#{above_timestamp}'::timestamp ), 0 ),
+        point( date_part( 'epoch', '#{above_timestamp}'::timestamp ), 0 )
+      ) &&
+      box(
+        point( date_part( 'epoch', "history"."addresses"."valid_from" ), 0 ),
+        point( date_part( 'epoch', "history"."addresses"."valid_to"   ), 0 ),
+      )
+    ) AS "compositions" WHERE country_id = X
 
-    WITH compositions AS (
-      SELECT * FROM history.countries WHERE #{above_timestamp} >= valid_from AND #{above_timestamp} < valid_to
-    ) SELECT * FROM compositions WHERE country_id = X
-    
 And `.joins` works as well:
 
     Country.as_of(1.month.ago).joins(:compositions)
-    
+
 Will execute:
 
-    WITH countries AS (
-      SELECT * FROM history.countries WHERE #{1.year.ago.utc} >= valid_from AND #{1.year.ago.utc} < valid_to
-    ), compositions AS (
-      SELECT * FROM history.countries WHERE #{above_timestamp} >= valid_from AND #{above_timestamp} < valid_to
-    ) SELECT * FROM countries INNER JOIN countries ON compositions.country_id = countries.id
+    SELECT "countries".* FROM (
+      # .. countries history query ..
+    ) AS "countries" INNER JOIN (
+      # .. compositions history query ..
+    ) AS "compositions" ON compositions.country_id = countries.id
 
 More methods are provided, see the
 [TimeMachine](https://github.com/ifad/chronomodel/blob/master/lib/chrono_model/time_machine.rb) source
@@ -166,25 +182,38 @@ them in your output, use `rake VERBOSE=true`.
 
 ## Caveats
 
- * `.includes` still doesn't work, but it'll fixed soon.
+ * The rules and temporal indexes cannot be saved in schema.rb. The AR
+   schema dumper is quite basic, and it isn't (currently) extensible.
+   As we're using many database-specific features, you'll better off with
+   the SQL schema dumper (`config.active_record.schema_format = :sql` in
+   `config/application.rb`). Be sure to add [these
+   files](https://gist.github.com/4548844) in your `lib/tasks` if you want
+   `rake db:setup` to work.
+
+ * `.includes` still doesn't work, but it'll fixed.
 
- * Some monkeypatching has been necessary both to `ActiveRecord::Relation` and
-   to `Arel::Visitors::ToSql` to fix a bug with `WITH` queries generation. This
-   will be reported to the upstream with a pull request after extensive testing.
+ * The history queries are very verbose, they should be factored out using a
+   `FUNCTION`.
 
  * The migration statements extension is implemented using a Man-in-the-middle
    class that inherits from the PostgreSQL adapter, and that relies on some
-   private APIs. This should be made more maintainable, maybe by implementing
-   an extension framework for connection adapters. This library will (clearly)
-   never be merged into Rails, as it is against its principle of treating the
-   SQL database as a dummy data store.
-
- * The schema dumper is WAY TOO hacky.
+   private APIs. This should be made more maintainable, maybe by requiring
+   the use of `adapter: chronomodel` or `adapter: chrono_postgresql`.
 
  * Savepoints are disabled, because there is
    [currently](http://archives.postgresql.org/pgsql-hackers/2012-08/msg01094.php)
    no way to identify a subtransaction belonging to the current transaction.
 
+ * The choice of using subqueries instead of [Common Table Expressions](http://www.postgresql.org/docs/9.0/static/queries-with.html)
+   was dictated by the fact that CTEs [currently acts as an optimization
+   fence](http://archives.postgresql.org/pgsql-hackers/2012-09/msg00700.php).
+   If it will be possible [to opt-out of the
+   fence](http://archives.postgresql.org/pgsql-hackers/2012-10/msg00024.php)
+   in the future, they will be probably be used again as they were [in the
+   past](https://github.com/ifad/chronomodel/commit/18f4c4b), because the
+   resulting queries are much more readable, and do not inhibit using
+   `.from()` from ARel.
+
 
 ## Contributing
 

data/README.sql

@@ -24,32 +24,36 @@ create table history.countries (
   hid         serial primary key,
   valid_from  timestamp not null,
   valid_to    timestamp not null default '9999-12-31',
-  recorded_at timestamp not null default now(),
+  recorded_at timestamp not null default timezone('UTC', now()),
 
   constraint from_before_to check (valid_from < valid_to),
 
   constraint overlapping_times exclude using gist (
     box(
-      point( extract( epoch from valid_from), id ),
-      point( extract( epoch from valid_to - interval '1 millisecond'), id )
+      point( date_part( 'epoch', valid_from), id ),
+      point( date_part( 'epoch', valid_to - interval '1 millisecond'), id )
     ) with &&
   )
 ) inherits ( temporal.countries );
 
 -- Inherited primary key
-create index country_inherit_pkey ON countries ( id )
+create index country_inherit_pkey on history.countries ( id )
 
--- Snapshot of all entities at a specific point in time
-create index country_snapshot          on history.countries ( valid_from, valid_to )
-
--- Snapshot of a single entity at a specific point in time
-create index country_instance_snapshot on history.countries ( id, valid_from, valid_to )
+-- Snapshot of data at a specific point in time
+create index country_snapshot on history.countries USING gist (
+  box(
+    point( date_part( 'epoch', valid_from ), 0 ),
+    point( date_part( 'epoch', valid_to   ), 0 )
+  )
+)
 
--- History update
-create index country_instance_update   on history.countries ( id, valid_to )
+-- Used by the rules queries when UPDATE'ing and DELETE'ing
+create index country_valid_from  on history.countries ( valid_from )
+create index country_valid_to    on history.countries ( valid_from )
+create index country_recorded_at on history.countries ( id, valid_to )
 
 -- Single instance whole history
-create index country_instance_history  on history.countries ( id, recorded_at )
+create index country_instance_history on history.countries ( id, recorded_at )
 
 
 -- The countries view, what the Rails' application ORM will actually CRUD on, and
@@ -57,42 +61,84 @@ create index country_instance_history  on history.countries ( id, recorded_at )
 --
 -- SELECT - return only current data
 --
-create view public.countries as select * from only temporal.countries;
+create view public.countries as select *, xmin as __xid from only temporal.countries;
 
 -- INSERT - insert data both in the current data table and in the history table.
--- Return data from the history table as the RETURNING clause must be the last
--- one in the rule.
+--
+-- A trigger is required if there is a serial ID column, as rules by
+-- design cannot handle the following case:
+--
+--   * INSERT INTO ... SELECT: if using currval(), all the rows
+--     inserted in the history will have the same identity value;
+--
+--   * if using a separate sequence to solve the above case, it may go
+--     out of sync with the main one if an INSERT statement fails due
+--     to a table constraint (the first one is nextval()'ed but the
+--     nextval() on the history one never happens)
+--
+-- So, only for this case, we resort to an AFTER INSERT FOR EACH ROW trigger.
+--
+-- Ref: GH Issue #4.
+--
 create rule countries_ins as on insert to public.countries do instead (
-  insert into temporal.countries ( name ) values ( new.name );
 
-  insert into history.countries ( id, name, valid_from )
-    values ( currval('temporal.countries_id_seq'), new.name, now() )
-    returning ( new.name )
+  insert into temporal.countries ( name ) values ( new.name );
+  returning ( id, new.name, xmin )
 );
 
+create or replace function temporal.countries_ins() returns trigger as $$
+  begin
+    insert into history.countries ( id, name, valid_from )
+    values ( currval('temporal.countries_id_seq'), new.name, timezone('utc', now()) );
+    return null;
+  end;
+$$ language plpgsql;
+
+create trigger history_ins after insert on temporal.countries_ins()
+  for each row execute procedure temporal.countries_ins();
+
 -- UPDATE - set the last history entry validity to now, save the current data in
 -- a new history entry and update the current table with the new data.
+-- In transactions, create the new history entry only on the first statement,
+-- and update the history instead on subsequent ones.
 --
-create rule countries_upd as on update to countries do instead (
+create rule countries_upd_first as on update to countries
+where old.__xid::char(10)::int8 <> (txid_current() & (2^32-1)::int8)
+do instead (
   update history.countries
-    set   valid_to = now()
-    where id       = old.id and valid_to = '9999-12-31';
+     set valid_to = timezone('UTC', now())
+   where id = old.id and valid_to = '9999-12-31';
 
   insert into history.countries ( id, name, valid_from ) 
-  values ( old.id, new.name, now() );
+  values ( old.id, new.name, timezone('UTC', now()) );
 
   update only temporal.countries
-    set name = new.name
-    where id = old.id
+     set name = new.name
+   where id = old.id
 );
+create rule countries_upd_next as on update to countries do instead (
+  update history.countries
+     set name = new.name
+   where id = old.id and valid_from = timezone('UTC', now())
+
+  update only temporal.countries
+     set name = new.name
+   where id = old.id
+)
 
 -- DELETE - save the current data in the history and eventually delete the data
--- from the current table.
+-- from the current table. Special case for records INSERTed and DELETEd in the
+-- same transaction - they won't appear at all in history.
 --
 create rule countries_del as on delete to countries do instead (
+  delete from history.countries
+   where id = old.id
+     and valid_from = timezone('UTC', now())
+     and valid_to   = '9999-12-31'
+
   update history.countries
     set   valid_to = now()
-    where id       = old.id and valid_to = '9999-12-31';
+    where id = old.id and valid_to = '9999-12-31';
 
   delete from only temporal.countries
   where temporal.countries.id = old.id

data/lib/chrono_model/adapter.rb

@@ -28,7 +28,10 @@ module ChronoModel
       return super unless options[:temporal]
 
       if options[:id] == false
-        raise Error, "Temporal tables require a primary key."
+        logger.warn "WARNING - Temporal Temporal tables require a primary key."
+        logger.warn "WARNING - Creating a \"__chrono_id\" primary key to fulfill the requirement"
+
+        options[:id] = '__chrono_id'
       end
 
       # Create required schemas
@@ -87,6 +90,10 @@ module ChronoModel
           if !is_chrono?(table_name)
             # Add temporal features to this table
             #
+            if !primary_key(table_name)
+              execute "ALTER TABLE #{table_name} ADD __chrono_id SERIAL PRIMARY KEY"
+            end
+
             execute "ALTER TABLE #{table_name} SET SCHEMA #{TEMPORAL_SCHEMA}"
             _on_history_schema { chrono_create_history_for(table_name) }
             chrono_create_view_for(table_name)
@@ -118,10 +125,15 @@ module ChronoModel
             # Remove temporal features from this table
             #
             execute "DROP VIEW #{table_name}"
+            _on_temporal_schema { execute "DROP FUNCTION IF EXISTS #{table_name}_ins() CASCADE" }
             _on_history_schema { execute "DROP TABLE #{table_name}" }
 
             default_schema = select_value 'SELECT current_schema()'
             _on_temporal_schema do
+              if primary_key(table_name) == '__chrono_id'
+                execute "ALTER TABLE #{table_name} DROP __chrono_id"
+              end
+
               execute "ALTER TABLE #{table_name} SET SCHEMA #{default_schema}"
             end
 
@@ -252,6 +264,138 @@ module ChronoModel
       end
     end
 
+    # Create spatial indexes for timestamp search. Conceptually identical
+    # to the EXCLUDE constraint in chrono_create_history_for, but without
+    # the millisecond skew.
+    #
+    # This index is used by +TimeMachine.at+, `.current` and `.past` to
+    # build the temporal WHERE clauses that fetch the state of records at
+    # a single point in time.
+    #
+    # Parameters:
+    #
+    #   `table`: the table where to create indexes on
+    #   `from` : the starting timestamp field
+    #   `to`   : the ending timestamp field
+    #
+    # Options:
+    #
+    #   `:name`: the index name prefix, defaults to
+    #            {table_name}_temporal_{snapshot / from_col / to_col}
+    #
+    def add_temporal_indexes(table, from, to, options = {})
+      snapshot_idx, from_idx, to_idx =
+        temporal_index_names(table, from, to, options)
+
+      chrono_alter_index(table, options) do
+        execute <<-SQL
+          CREATE INDEX #{snapshot_idx} ON #{table} USING gist (
+            box(
+              point( date_part( 'epoch', #{from} ), 0 ),
+              point( date_part( 'epoch', #{to  } ), 0 )
+            )
+          )
+        SQL
+
+        # Indexes used for precise history filtering, sorting and, in history
+        # tables, by UPDATE / DELETE rules
+        #
+        execute "CREATE INDEX #{from_idx} ON #{table} ( #{from} )"
+        execute "CREATE INDEX #{to_idx  } ON #{table} ( #{to  } )"
+      end
+    end
+
+    def remove_temporal_indexes(table, from, to, options = {})
+      indexes = temporal_index_names(table, from, to, options)
+
+      chrono_alter_index(table, options) do
+        indexes.each {|idx| execute "DROP INDEX #{idx}" }
+      end
+    end
+
+    def temporal_index_names(table, from, to, options)
+      prefix = options[:name].presence || "#{table}_temporal"
+
+      ["#{from}_and_#{to}", from, to].map do |suffix|
+        [prefix, 'on', suffix].join('_')
+      end
+    end
+
+
+    # Adds a CHECK constraint to the given +table+, to assure that
+    # the value contained in the +from+ field is, by default, less
+    # than the value contained in the +to+ field.
+    #
+    # The default `<` operator can be changed using the `:op` option.
+    #
+    def add_from_before_to_constraint(table, from, to, options = {})
+      operator = options[:op].presence || '<'
+      name = from_before_to_constraint_name(table, from, to)
+
+      chrono_alter_constraint(table, options) do
+        execute <<-SQL
+          ALTER TABLE #{table} ADD CONSTRAINT
+            #{name} CHECK (#{from} #{operator} #{to})
+        SQL
+      end
+    end
+
+    def remove_from_before_to_constraint(table, from, to, options = {})
+      name = from_before_to_constraint_name(table, from, to)
+
+      chrono_alter_constraint(table, options) do
+        execute <<-SQL
+          ALTER TABLE #{table} DROP CONSTRAINT #{name}
+        SQL
+      end
+    end
+
+    def from_before_to_constraint_name(table, from, to)
+      "#{table}_#{from}_before_#{to}"
+    end
+
+
+    # Adds an EXCLUDE constraint to the given table, to assure that
+    # no more than one record can occupy a definite segment on a
+    # timeline.
+    #
+    # The exclusion is implemented using a spatial gist index, that
+    # uses boxes under the hood. Different records are identified by
+    # default using the table's primary key - or you can specify your
+    # field (or composite field) using the `:id` option.
+    #
+    def add_timeline_consistency_constraint(table, from, to, options = {})
+      name = timeline_consistency_constraint_name(table)
+      id = options[:id] || primary_key(table)
+
+      chrono_alter_constraint(table, options) do
+        execute <<-SQL
+          ALTER TABLE #{table} ADD CONSTRAINT
+            #{name} EXCLUDE USING gist (
+              box(
+                point( date_part( 'epoch', #{from} ), #{id} ),
+                point( date_part( 'epoch', #{to  } - INTERVAL '1 msec' ), #{id} )
+              )
+              WITH &&
+            )
+        SQL
+      end
+    end
+
+    def remove_timeline_consistency_constraint(table, from, to, options = {})
+      name = timeline_consistency_constraint_name(table)
+      chrono_alter_constraint(table, options) do
+        execute <<-SQL
+          ALTER TABLE #{table} DROP CONSTRAINT #{name}
+        SQL
+      end
+    end
+
+    def timeline_consistency_constraint_name(table)
+      "#{table}_timeline_consistency"
+    end
+
+
     # Evaluates the given block in the given +schema+ search path.
     #
     # By default, nested call are allowed, to disable this feature
@@ -331,39 +475,32 @@ module ChronoModel
             hid         SERIAL PRIMARY KEY,
             valid_from  timestamp NOT NULL,
             valid_to    timestamp NOT NULL DEFAULT '9999-12-31',
-            recorded_at timestamp NOT NULL DEFAULT timezone('UTC', now()),
-
-            CONSTRAINT #{table}_from_before_to CHECK (valid_from < valid_to),
-
-            CONSTRAINT #{table}_overlapping_times EXCLUDE USING gist (
-              box(
-                point( extract( epoch FROM valid_from), id ),
-                point( extract( epoch FROM valid_to - INTERVAL '1 millisecond'), id )
-              ) with &&
-            )
+            recorded_at timestamp NOT NULL DEFAULT timezone('UTC', now())
           ) INHERITS ( #{parent} )
         SQL
 
+        add_from_before_to_constraint(table, :valid_from, :valid_to,
+          :on_current_schema => true)
+
+        add_timeline_consistency_constraint(table, :valid_from, :valid_to,
+          :id => p_pkey, :on_current_schema => true)
+
         # Inherited primary key
         execute "CREATE INDEX #{table}_inherit_pkey ON #{table} ( #{p_pkey} )"
-        # Snapshot of all entities at a specific point in time
-        execute "CREATE INDEX #{table}_snapshot     ON #{table} ( valid_from, valid_to )"
-
-        if postgresql_version >= 90100
-          # PG 9.1 makes efficient use of single-column indexes
-          execute "CREATE INDEX #{table}_valid_from   ON #{table} ( valid_from )"
-          execute "CREATE INDEX #{table}_valid_to     ON #{table} ( valid_to )"
-          execute "CREATE INDEX #{table}_recorded_at  ON #{table} ( recorded_at )"
-        else
-          # PG 9.0 requires multi-column indexes instead.
-          #
-          # Snapshot of a single entity at a specific point in time
-          execute "CREATE INDEX #{table}_instance_snapshot ON #{table} ( id, valid_from, valid_to )"
-          # History update
-          execute "CREATE INDEX #{table}_instance_update   ON #{table} ( id, valid_to )"
-          # Single instance whole history
-          execute "CREATE INDEX #{table}_instance_history  ON #{table} ( id, recorded_at )"
-        end
+
+        chrono_create_history_indexes_for(table, p_pkey)
+      end
+
+      def chrono_create_history_indexes_for(table, p_pkey = nil)
+        # Duplicate because of Migrate.upgrade_indexes_for
+        # TODO remove me.
+        p_pkey ||= primary_key("#{TEMPORAL_SCHEMA}.#{table}")
+
+        add_temporal_indexes table, :valid_from, :valid_to,
+          :on_current_schema => true
+
+        execute "CREATE INDEX #{table}_recorded_at      ON #{table} ( recorded_at )"
+        execute "CREATE INDEX #{table}_instance_history ON #{table} ( #{p_pkey}, recorded_at )"
       end
 
       # Create the public view and its rewrite rules
@@ -378,31 +515,52 @@ module ChronoModel
         execute "DROP VIEW #{table}" if table_exists? table
         execute "CREATE VIEW #{table} AS SELECT *, xmin AS __xid FROM ONLY #{current}"
 
-        columns  = columns(table).map(&:name)
-        sequence = serial_sequence(current, pk)                    # For INSERT
-        updates  = columns.map {|c| "#{c} = new.#{c}"}.join(",\n") # For UPDATE
+        columns = columns(table).map{|c| quote_column_name(c.name)}
+        columns.delete(quote_column_name(pk))
 
-        columns.delete(pk)
+        updates = columns.map {|c| "#{c} = new.#{c}"}.join(",\n")
 
         fields, values = columns.join(', '), columns.map {|c| "new.#{c}"}.join(', ')
+        fields_with_pk, values_with_pk = "#{pk}, " << fields, "new.#{pk}, " << values
 
-        # INSERT - inert data both in the temporal table and in the history one.
+        # INSERT - insert data both in the temporal table and in the history one.
+        #
+        # A trigger is required if there is a serial ID column, as rules by
+        # design cannot handle the following case:
         #
-        if sequence.present?
+        #   * INSERT INTO ... SELECT: if using currval(), all the rows
+        #     inserted in the history will have the same identity value;
+        #
+        #   * if using a separate sequence to solve the above case, it may go
+        #     out of sync with the main one if an INSERT statement fails due
+        #     to a table constraint (the first one is nextval()'ed but the
+        #     nextval() on the history one never happens)
+        #
+        # So, only for this case, we resort to an AFTER INSERT FOR EACH ROW trigger.
+        #
+        # Ref: GH Issue #4.
+        #
+        if serial_sequence(current, pk).present?
           execute <<-SQL
             CREATE RULE #{table}_ins AS ON INSERT TO #{table} DO INSTEAD (
+              INSERT INTO #{current} ( #{fields} ) VALUES ( #{values} )
+              RETURNING #{pk}, #{fields}, xmin
+            );
 
-              INSERT INTO #{current} ( #{fields} ) VALUES ( #{values} );
+            CREATE OR REPLACE FUNCTION #{current}_ins() RETURNS TRIGGER AS $$
+              BEGIN
+                INSERT INTO #{history} ( #{fields_with_pk}, valid_from )
+                VALUES ( #{values_with_pk}, timezone('UTC', now()) );
+                RETURN NULL;
+              END;
+            $$ LANGUAGE plpgsql;
 
-              INSERT INTO #{history} ( #{pk}, #{fields}, valid_from )
-              VALUES ( currval('#{sequence}'), #{values}, timezone('UTC', now()) )
-              RETURNING #{pk}, #{fields}, xmin
-            )
+            DROP TRIGGER IF EXISTS history_ins ON #{current};
+
+            CREATE TRIGGER history_ins AFTER INSERT ON #{current}
+              FOR EACH ROW EXECUTE PROCEDURE #{current}_ins();
           SQL
         else
-          fields_with_pk = "#{pk}, " << fields
-          values_with_pk = "new.#{pk}, " << values
-
           execute <<-SQL
             CREATE RULE #{table}_ins AS ON INSERT TO #{table} DO INSTEAD (
 
@@ -410,7 +568,7 @@ module ChronoModel
 
               INSERT INTO #{history} ( #{fields_with_pk}, valid_from )
               VALUES ( #{values_with_pk}, timezone('UTC', now()) )
-              RETURNING #{fields_with_pk}
+              RETURNING #{fields_with_pk}, xmin
             )
           SQL
         end
@@ -501,6 +659,31 @@ module ChronoModel
         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)
+        if is_chrono?(table_name) && !options[:on_current_schema]
+          _on_temporal_schema { yield }
+          _on_history_schema { yield }
+        else
+          yield
+        end
+      end
+
+      def chrono_alter_constraint(table_name, options)
+        if is_chrono?(table_name) && !options[:on_current_schema]
+          _on_temporal_schema { yield }
+        else
+          yield
+        end
+      end
+
       def _on_temporal_schema(nesting = true, &block)
         on_schema(TEMPORAL_SCHEMA, nesting, &block)
       end
@@ -508,6 +691,14 @@ module ChronoModel
       def _on_history_schema(nesting = true, &block)
         on_schema(HISTORY_SCHEMA, nesting, &block)
       end
+
+      def translate_exception(exception, message)
+        if exception.message =~ /conflicting key value violates exclusion constraint/
+          ActiveRecord::RecordNotUnique.new(message, exception)
+        else
+          super
+        end
+      end
   end
 
 end