chrono_model 0.3.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+spec/config.yml
+spec/debug.log
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chrono_model.gemspec
+gemspec
+
+group :development do
+  gem 'ruby-debug19'
+  gem 'pry'
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Marcello Barnaba <m.barnaba@ifad.org>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+# ChronoModel
+
+A temporal database system on PostgreSQL using
+[table inheritance](http://www.postgresql.org/docs/9.0/static/ddl-inherit.html) and
+[the rule system](http://www.postgresql.org/docs/9.0/static/rules-update.html).
+
+This is a data structure for a
+[Slowly-Changing Dimension Type 2](http://en.wikipedia.org/wiki/Slowly_changing_dimension#Type_2)
+temporal database, implemented using only [PostgreSQL](http://www.postgresql.org) >= 9.0 features.
+
+All the history recording is done inside the database system, freeing the application code from
+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).
+
+Current data is hold in a table in the `current` [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
+yet.
+
+The updatable view is created in the default `public` schema, making it visible to Active Record.
+
+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.
+
+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.
+
+Optimal temporal timestamps indexing is provided for both PostgreSQL 9.0 and 9.1 query planners.
+
+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
+defining this temporal schema for a single table.
+
+
+## Requirements
+
+* Ruby &gt;= 1.9.2
+* Active Record &gt;= 3.2
+* PostgreSQL &gt;= 9.0
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chrono_model', :git => 'git://github.com/ifad/chronomodel'
+
+And then execute:
+
+    $ bundle
+
+
+## Schema creation
+
+This library hooks all `ActiveRecord::Migration` methods to make them temporal aware.
+
+The only option added is `:temporal => true` to `create_table`:
+
+    create_table :countries, :temporal => true do |t|
+      t.string :common_name
+      t.references :currency
+      # ...
+    end
+
+That'll create the _current_, its _history_ child table and the _public_ view.
+Every other housekeeping of the temporal structure is handled behind the scenes
+by the other schema statements. E.g.:
+
+ * `rename_table`  - renames tables, views, sequences, indexes and rules
+ * `drop_table`    - drops the temporal table and all dependant objects
+ * `add_column`    - adds the column to the current table and updates rules
+ * `rename_column` - renames the current table column and updates the rules
+ * `remove_column` - removes the current table column and updates the rules
+ * `add_index`     - creates the index in the history table as well
+ * `remove_index`  - removes the index from the history table as well
+
+
+## Data querying
+
+A model backed by a temporal view will behave like any other model backed by a
+plain table. If you want to do as-of-date queries, you need to include the
+`ChronoModel::TimeMachine` module in your model.
+
+    module Country < ActiveRecord::Base
+      include ChronoModel::TimeMachine
+
+      has_many :compositions
+    end
+
+This will make an `as_of` class method available to your model. E.g.:
+
+    Country.as_of(1.year.ago)
+
+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
+
+This work on associations using temporal extensions as well:
+
+    Country.as_of(1.year.ago).first.compositions
+
+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
+
+    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
+
+More methods are provided, see the
+[TimeMachine](https://github.com/ifad/chronomodel/blob/master/lib/chrono_model/time_machine.rb) source
+for more information.
+
+
+## Running tests
+
+You need a running Postgresql instance. Create `spec/config.yml` with the
+connection authentication details (use `spec/config.yml.example` as template).
+
+Run `rake`. SQL queries are logged to `spec/debug.log`. If you want to see
+them in your output, use `rake VERBOSE=true`.
+
+## Caveats
+
+ * `.includes` still doesn't work, but it'll fixed soon.
+
+ * 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 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.
+
+
+## Contributing
+
+ 1. Fork it
+ 2. Create your feature branch (`git checkout -b my-new-feature`)
+ 3. Commit your changes (`git commit -am 'Added some feature'`)
+ 4. Push to the branch (`git push origin my-new-feature`)
+ 5. Create new Pull Request

data/README.sql

@@ -0,0 +1,101 @@
+------------------------------------------------------
+-- Temporal schema for an example "countries" relation
+--
+-- http://github.com/ifad/chronomodel
+--
+create schema temporal; -- schema containing all temporal tables
+create schema history;  -- schema containing all history tables
+
+-- Current countries data - nothing special
+--
+create table temporal.countries (
+  id   serial primary key,
+  name varchar
+);
+
+-- Countries historical data.
+--
+-- Inheritance is used to avoid duplicating the schema from the main table.
+-- Please note that columns on the main table cannot be dropped, and other caveats
+-- http://www.postgresql.org/docs/9.0/static/ddl-inherit.html#DDL-INHERIT-CAVEATS
+--
+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(),
+
+  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 )
+    ) with &&
+  )
+) inherits ( temporal.countries );
+
+-- Inherited primary key
+create index country_inherit_pkey ON 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 )
+
+-- History update
+create index country_instance_update   on history.countries ( id, valid_to )
+
+-- Single instance whole history
+create index country_instance_history  on history.countries ( id, recorded_at )
+
+
+-- The countries view, what the Rails' application ORM will actually CRUD on, and
+-- the core of the temporal updates.
+--
+-- SELECT - return only current data
+--
+create view public.countries as select * 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.
+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 )
+);
+
+-- 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.
+--
+create rule countries_upd as on update to countries do instead (
+  update history.countries
+    set   valid_to = 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() );
+
+  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.
+--
+create rule countries_del as on delete to countries do instead (
+  update history.countries
+    set   valid_to = now()
+    where id       = old.id and valid_to = '9999-12-31';
+
+  delete from only temporal.countries
+  where temporal.countries.id = old.id
+);
+
+-- EOF

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+# RSpec
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/chrono_model.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/chrono_model/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Marcello Barnaba"]
+  gem.email         = ["vjt@openssl.it"]
+  gem.description   = %q{Give your models as-of date temporal extensions. Built entirely for PostgreSQL >= 9.0}
+  gem.summary       = %q{Temporal extensions (SCD Type II) for Active Record}
+  gem.homepage      = "http://github.com/ifad/chronomodel"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "chrono_model"
+  gem.require_paths = ["lib"]
+  gem.version       = ChronoModel::VERSION
+
+  gem.add_dependency "activerecord", "~> 3.2"
+  gem.add_dependency "pg"
+end

data/lib/chrono_model.rb

@@ -0,0 +1,34 @@
+require 'chrono_model/version'
+require 'chrono_model/adapter'
+require 'chrono_model/compatibility'
+require 'chrono_model/patches'
+require 'chrono_model/time_machine'
+
+module ChronoModel
+  class Error < ActiveRecord::ActiveRecordError #:nodoc:
+  end
+end
+
+if defined?(Rails)
+  require 'chrono_model/railtie'
+end
+
+# Install it.
+silence_warnings do
+  # Replace AR's PG adapter with the ChronoModel one. This (dirty) approach is
+  # required because the PG adapter defines +add_column+ itself, thus making
+  # impossible to use super() in overridden Module methods.
+  #
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter = ChronoModel::Adapter
+
+  # We need to override the "scoped" method on AR::Association for temporal
+  # associations to work as well
+  ActiveRecord::Associations::Association = ChronoModel::Patches::Association
+
+  # This implements correct WITH syntax on PostgreSQL
+  Arel::Visitors::PostgreSQL = ChronoModel::Patches::Visitor
+
+  # This adds .with support to ActiveRecord::Relation
+  ActiveRecord::Relation.instance_eval { include ChronoModel::Patches::QueryMethods }
+  ActiveRecord::Base.extend ChronoModel::Patches::Querying
+end

data/lib/chrono_model/adapter.rb

@@ -0,0 +1,423 @@
+require 'active_record'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ChronoModel
+
+  # This class implements all ActiveRecord::ConnectionAdapters::SchemaStatements
+  # methods adding support for temporal extensions. It inherits from the Postgres
+  # adapter for a clean override of its methods using super.
+  #
+  class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    TEMPORAL_SCHEMA = 'temporal' # The schema holding current data
+    HISTORY_SCHEMA  = 'history'  # The schema holding historical data
+
+    def chrono_supported?
+      postgresql_version >= 90000
+    end
+
+    # Creates the given table, possibly creating the temporal schema
+    # objects if the `:temporal` option is given and set to true.
+    #
+    def create_table(table_name, options = {})
+      # No temporal features requested, skip
+      return super unless options[:temporal]
+
+      if options[:id] == false
+        raise Error, "Temporal tables require a primary key."
+      end
+
+      # Create required schemas
+      chrono_create_schemas!
+
+      transaction do
+        _on_temporal_schema { super }
+        _on_history_schema { chrono_create_history_for(table_name) }
+
+        chrono_create_view_for(table_name)
+
+        TableCache.add! table_name
+      end
+    end
+
+    # If renaming a temporal table, rename the history and view as well.
+    #
+    def rename_table(name, new_name)
+      return super unless is_chrono?(name)
+
+      clear_cache!
+
+      transaction do
+        [TEMPORAL_SCHEMA, HISTORY_SCHEMA].each do |schema|
+          on_schema(schema) do
+            seq     = serial_sequence(name, primary_key(name))
+            new_seq = seq.sub(name.to_s, new_name.to_s).split('.').last
+
+            execute "ALTER SEQUENCE #{seq}  RENAME TO #{new_seq}"
+            execute "ALTER TABLE    #{name} RENAME TO #{new_name}"
+          end
+        end
+
+        execute "ALTER VIEW #{name} RENAME TO #{new_name}"
+
+        TableCache.del! name
+        TableCache.add! new_name
+      end
+    end
+
+    # If changing a temporal table, redirect the change to the table in the
+    # temporal schema and recreate views.
+    #
+    # If the `:temporal` option is specified, enables or disables temporal
+    # features on the given table. Please note that you'll lose your history
+    # when demoting a temporal table to a plain one.
+    #
+    def change_table(table_name, options = {}, &block)
+      transaction do
+
+        # Add an empty proc to support calling change_table without a block.
+        #
+        block ||= proc { }
+
+        if options[:temporal] == true
+          if !is_chrono?(table_name)
+            # Add temporal features to this table
+            #
+            execute "ALTER TABLE #{table_name} SET SCHEMA #{TEMPORAL_SCHEMA}"
+            _on_history_schema { chrono_create_history_for(table_name) }
+            chrono_create_view_for(table_name)
+
+            TableCache.add! table_name
+          end
+
+          chrono_alter(table_name) { super table_name, options, &block }
+        else
+          if options[:temporal] == false && is_chrono?(table_name)
+            # Remove temporal features from this table
+            #
+            execute "DROP VIEW #{table_name}"
+            _on_history_schema { execute "DROP TABLE #{table_name}" }
+
+            default_schema = select_value 'SELECT current_schema()'
+            _on_temporal_schema do
+              execute "ALTER TABLE #{table_name} SET SCHEMA #{default_schema}"
+            end
+
+            TableCache.del! table_name
+          end
+
+          super table_name, options, &block
+        end
+      end
+    end
+
+    # If dropping a temporal table, drops it from the temporal schema
+    # adding the CASCADE option so to delete the history, view and rules.
+    #
+    def drop_table(table_name, *)
+      return super unless is_chrono?(table_name)
+
+      _on_temporal_schema { execute "DROP TABLE #{table_name} CASCADE" }
+
+      TableCache.del! table_name
+    end
+
+    # If adding an index to a temporal table, add it to the one in the
+    # temporal schema and to the history one. If the `:unique` option is
+    # present, it is removed from the index created in the history table.
+    #
+    def add_index(table_name, column_name, options = {})
+      return super unless is_chrono?(table_name)
+
+      transaction do
+        _on_temporal_schema { super }
+
+        # Uniqueness constraints do not make sense in the history table
+        options = options.dup.tap {|o| o.delete(:unique)} if options[:unique].present?
+
+        _on_history_schema { super table_name, column_name, options }
+      end
+    end
+
+    # If removing an index from a temporal table, remove it both from the
+    # temporal and the history schemas.
+    #
+    def remove_index(table_name, *)
+      return super unless is_chrono?(table_name)
+
+      transaction do
+        _on_temporal_schema { super }
+        _on_history_schema { super }
+      end
+    end
+
+    # If adding a column to a temporal table, creates it in the table in
+    # the temporal schema and updates the view rules.
+    #
+    def add_column(table_name, *)
+      return super unless is_chrono?(table_name)
+
+      transaction do
+        # Add the column to the temporal table
+        _on_temporal_schema { super }
+
+        # Update the rules
+        chrono_create_view_for(table_name)
+      end
+    end
+
+    # If renaming a column of a temporal table, rename it in the table in
+    # the temporal schema and update the view rules.
+    #
+    def rename_column(table_name, *)
+      return super unless is_chrono?(table_name)
+
+      # Rename the column in the temporal table and in the view
+      transaction do
+        _on_temporal_schema { super }
+        super
+
+        # Update the rules
+        chrono_create_view_for(table_name)
+      end
+    end
+
+    # If removing a column from a temporal table, we are forced to drop the
+    # view, then change the column from the table in the temporal schema and
+    # eventually recreate the rules.
+    #
+    def change_column(table_name, *)
+      return super unless is_chrono?(table_name)
+      chrono_alter(table_name) { super }
+    end
+
+    # Change the default on the temporal schema table.
+    #
+    def change_column_default(table_name, *)
+      return super unless is_chrono?(table_name)
+      _on_temporal_schema { super }
+    end
+
+    # Change the null constraint on the temporal schema table.
+    #
+    def change_column_null(table_name, *)
+      return super unless is_chrono?(table_name)
+      _on_temporal_schema { super }
+    end
+
+    # If removing a column from a temporal table, we are forced to drop the
+    # view, then drop the column from the table in the temporal schema and
+    # eventually recreate the rules.
+    #
+    def remove_column(table_name, *)
+      return super unless is_chrono?(table_name)
+      chrono_alter(table_name) { super }
+    end
+
+    # Runs column_definitions, primary_key and indexes in the temporal schema,
+    # as the table there defined is the source for this information.
+    #
+    # Moreover, the PostgreSQLAdapter +indexes+ method uses current_schema(),
+    # thus this is the only (and cleanest) way to make injection work.
+    #
+    # Schema nesting is disabled on these calls, make sure to fetch metadata
+    # from the first caller's selected schema and not from the current one.
+    #
+    [:column_definitions, :primary_key, :indexes].each do |method|
+      define_method(method) do |table_name|
+        return super(table_name) unless is_chrono?(table_name)
+        _on_temporal_schema(false) { super(table_name) }
+      end
+    end
+
+    # Evaluates the given block in the given +schema+ search path.
+    #
+    # By default, nested call are allowed, to disable this feature
+    # pass +false+ as the second parameter.
+    #
+    def on_schema(schema, nesting = true, &block)
+      @_on_schema_nesting = (@_on_schema_nesting || 0) + 1
+
+      if nesting || @_on_schema_nesting == 1
+        old_path = self.schema_search_path
+        self.schema_search_path = schema
+      end
+
+      block.call
+
+    ensure
+      if (nesting || @_on_schema_nesting == 1)
+
+        # If the transaction is aborted, any execute() call will raise
+        # "transaction is aborted errors" - thus calling the Adapter's
+        # setter won't update the memoized variable.
+        #
+        # Here we reset it to +nil+ to refresh it on the next call, as
+        # there is no way to know which path will be restored when the
+        # transaction ends.
+        #
+        if @connection.transaction_status == PGconn::PQTRANS_INERROR
+          @schema_search_path = nil
+        else
+          self.schema_search_path = old_path
+        end
+      end
+      @_on_schema_nesting -= 1
+    end
+
+    TableCache = (Class.new(HashWithIndifferentAccess) do
+      def all         ; keys;                 ; end
+      def add!  table ; self[table] = true    ; end
+      def del!  table ; self[table] = nil     ; end
+      def fetch table ; self[table] ||= yield ; end
+    end).new
+
+    # Returns true if the given name references a temporal table.
+    #
+    def is_chrono?(table)
+      TableCache.fetch(table) do
+        _on_temporal_schema { table_exists?(table) } &&
+        _on_history_schema { table_exists?(table) }
+      end
+    end
+
+    def chrono_create_schemas!
+      [TEMPORAL_SCHEMA, HISTORY_SCHEMA].each do |schema|
+        execute "CREATE SCHEMA #{schema}" unless schema_exists?(schema)
+      end
+    end
+
+    private
+      # Create the history table in the history schema
+      def chrono_create_history_for(table)
+        parent = "#{TEMPORAL_SCHEMA}.#{table}"
+        p_pkey = primary_key(parent)
+
+        execute <<-SQL
+          CREATE TABLE #{table} (
+            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 &&
+            )
+          ) INHERITS ( #{parent} )
+        SQL
+
+        # 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
+      end
+
+      # Create the public view and its rewrite rules
+      #
+      def chrono_create_view_for(table)
+        pk      = primary_key(table)
+        current = [TEMPORAL_SCHEMA, table].join('.')
+        history = [HISTORY_SCHEMA,  table].join('.')
+
+        # SELECT - return only current data
+        #
+        execute "CREATE OR REPLACE VIEW #{table} AS SELECT * 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.delete(pk)
+
+        fields, values = columns.join(', '), columns.map {|c| "new.#{c}"}.join(', ')
+
+        # INSERT - inert data both in the temporal table and in the history one.
+        #
+        execute <<-SQL
+          CREATE OR REPLACE RULE #{table}_ins AS ON INSERT TO #{table} DO INSTEAD (
+
+            INSERT INTO #{current} ( #{fields} ) VALUES ( #{values} );
+
+            INSERT INTO #{history} ( #{pk}, #{fields}, valid_from )
+            VALUES ( currval('#{sequence}'), #{values}, timezone('UTC', now()) )
+            RETURNING #{pk}, #{fields}
+          )
+        SQL
+
+        # 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.
+        #
+        execute <<-SQL
+          CREATE OR REPLACE RULE #{table}_upd AS ON UPDATE TO #{table} DO INSTEAD (
+
+            UPDATE #{history} SET valid_to = timezone('UTC', now())
+            WHERE #{pk} = old.#{pk} AND valid_to = '9999-12-31';
+
+            INSERT INTO #{history} ( #{pk}, #{fields}, valid_from )
+            VALUES ( old.#{pk}, #{values}, timezone('UTC', now()) );
+
+            UPDATE ONLY #{current} SET #{updates}
+            WHERE #{pk} = old.#{pk}
+          )
+        SQL
+
+        # DELETE - save the current data in the history and eventually delete the data
+        # from the temporal table.
+        #
+        execute <<-SQL
+          CREATE OR REPLACE RULE #{table}_del AS ON DELETE TO #{table} DO INSTEAD (
+
+            UPDATE #{history} SET valid_to = timezone('UTC', now())
+            WHERE #{pk} = old.#{pk} AND valid_to = '9999-12-31';
+
+            DELETE FROM ONLY #{current}
+            WHERE #{current}.#{pk} = old.#{pk}
+          )
+        SQL
+      end
+
+      # In destructive changes, such as removing columns or changing column
+      # types, the view must be dropped and recreated, while the change has
+      # to be applied to the table in the temporal schema.
+      #
+      def chrono_alter(table_name)
+        transaction do
+          execute "DROP VIEW #{table_name}"
+
+          _on_temporal_schema { yield }
+
+          # Recreate the rules
+          chrono_create_view_for(table_name)
+        end
+      end
+
+      def _on_temporal_schema(nesting = true, &block)
+        on_schema(TEMPORAL_SCHEMA, nesting, &block)
+      end
+
+      def _on_history_schema(nesting = true, &block)
+        on_schema(HISTORY_SCHEMA, nesting, &block)
+      end
+  end
+
+end