chrono_model 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d1cb1ec2f0637ba61fce647853f9e2d1690214fd
-  data.tar.gz: 0dd9231715441b128fa68599a2594dd2847fd449
+SHA256:
+  metadata.gz: 143b16e6e193bd56c88d1541f965150b07af191992aec7978dc94c84d7e53f87
+  data.tar.gz: 4aa06ed4110a6dbd9047f580b2972589d813f5108b422fe6ba0a80c021d56d03
 SHA512:
-  metadata.gz: 418fc68a58518d1bf8a9513f56f26598cdb195db0ceb7e8d6fa3b06061a9ca0f26f436462b1dfb666c47a1d549bbafea80be852ccb4cdd7081a203b1ca524844
-  data.tar.gz: c1ecc4413a82074372edddf75c86318f4e8995c6dcb3a4775419d7ee9b431eb37f4eadcb31ca3ac41e7d69bcbf4532044e681b001c65c481110e759442ef954d
+  metadata.gz: 57a62853b840b3edd78d1e0402c8d66458b01980956c87c880b84261490ed6f251a00b497c70f56646b4dd051869554118fc426d31b9bfda0af367e8977f3612
+  data.tar.gz: 854b001d29648c4b191eb7e985d720d72bd82cd43dc40df481cc63a83d684fe15922b8127ea40418ad89e5cc7cee30bb3e2551e2eeb6964bbb6477a97aa2f109

data/.travis.yml

@@ -1,3 +1,8 @@
+sudo: false
+
+language: ruby
+cache: bundler
+
 rvm:
   - 2.3
   - 2.4
@@ -8,27 +13,27 @@ gemfile:
   - gemfiles/rails_5.1.gemfile
   - gemfiles/rails_5.2.gemfile
 
-#matrix:
-#  exclude:
-#    - rvm: 2.4
-#      gemfile: gemfiles/rails_4.2.gemfile
-
-sudo: false
-
-language: ruby
-cache: bundler
-
 addons:
-  postgresql: "9.6"
-  apt:
-    packages: postgresql-plpython-9.6
   code_climate:
     repo_token: dedfb7472ee410eec459bff3681d9a8fd8dd237e9bd7e8675a7c8eb7e253bba9
 
-before_script:
+  postgresql: "10"
+  apt:
+    packages:
+      - postgresql-10
+      - postgresql-client-10
+
+before_install:
+  - sudo sed -i -e '/local.*peer/s/postgres/all/' -e 's/peer\|md5/trust/g' /etc/postgresql/*/main/pg_hba.conf
+  - sudo /etc/init.d/postgresql restart
+  - sleep 2
   - psql -c "CREATE DATABASE chronomodel;" -U postgres
   - psql -c "CREATE DATABASE chronomodel_railsapp;" -U postgres
 
+env:
+  global:
+    - PGPORT=5433
+
 script:
   - bundle exec rake TEST_CONFIG=./spec/config.travis.yml
 

data/README.md

@@ -1,15 +1,11 @@
 # Temporal database system on PostgreSQL using [updatable views][pg-updatable-views], [table inheritance][pg-table-inheritance] and [INSTEAD OF triggers][pg-instead-of-triggers].
 
 [![Build Status][build-status-badge]][build-status]
-[![Dependency Status][deps-status-badge]][deps-status]
 [![Code Climate][code-analysis-badge]][code-analysis]
 [![Test Coverage][test-coverage-badge]][test-coverage]
 [![Inlinedocs][docs-analysis-badge]][docs-analysis]
 
-![{chronos - greek god of time}][chronos-image]
-
-> Chronos, the greek god of time.
-> Courtesy of [REBELLE SOCIETY][rebelle-society]
+![{A Delorean that we all love}][delorean-image]
 
 ChronoModel implements what Oracle sells as "Flashback Queries", with standard
 SQL on free PostgreSQL. Academically speaking, ChronoModel implements a
@@ -67,17 +63,16 @@ All timestamps are _forcibly_ stored in as UTC, bypassing the
 
 * Ruby >= 2.3
 * Active Record >= 5.0. See the [detailed supported versions matrix on travis](https://travis-ci.org/ifad/chronomodel)
-* PostgreSQL >= 9.3
+* PostgreSQL >= 9.4 (legacy support for 9.3)
 * The `btree_gist` PostgreSQL extension
-* The `plpython` PostgreSQL extension if you have *JSON* (*not* JSONB) columns
 
 With Homebrew:
 
-    brew install --with-python postgres
+    brew install postgres
 
-With Apt:
+With apt:
 
-    apt-get install postgresql-plpython
+    apt-get install postgresql-11
 
 ## Installation
 
@@ -179,6 +174,21 @@ This is visible in `psql` if you issue a `\d+`. Example after a test run:
      public | test_table    | view     | chronomodel | 0 bytes    | {"temporal":true,"journal":["foo"],"chronomodel":"0.7.0.alpha"}
 
 
+## Using Rails Counter Cache
+
+**IMPORTANT**: Rails counter cache issues an UPDATE on the parent record
+table, thus triggering new history entries creation. You are **strongly**
+advised to NOT journal the counter cache columns, or race conditions will
+occur (see https://github.com/ifad/chronomodel/issues/71).
+
+In such cases, ensure to add `no_journal: %w( your_counter_cache_column_name )`
+to your `create_table`. Example:
+
+    create_table 'sections', temporal: true, no_journal: %w( articles_count ) do |t|
+      t.string :name
+      t.integer :articles_count, default: 0
+    end
+
 ## Data querying
 
 Include the `ChronoModel::TimeMachine` module in your model.
@@ -278,35 +288,51 @@ given that usually database objects have creation and dropping scripts.
 
 ## Running tests
 
-You need a running PostgreSQL >= 9.3 instance. Create `spec/config.yml` with the
+You need a running PostgreSQL >= 9.4 instance. Create `spec/config.yml` with the
 connection authentication details (use `spec/config.yml.example` as template).
 
 You need to connect as  a database superuser, because specs need to create the
 `btree_gist` extension.
 
-Run `rake`. SQL queries are logged to `spec/debug.log`. If you want to see them
-in your output, use `rake VERBOSE=true`.
+To run the full test suite, use
+
+    rake
 
+SQL queries are logged to `spec/debug.log`. If you want to see them in your
+output, set the `VERBOSE=true` environment variable.
+
+Some tests check the nominal execution of rake tasks within a test Rails app,
+and those are quite time consuming. You can run the full ChronoModel tests
+only against ActiveRecord by using
+
+    rspec spec/chrono_model
+
+Ensure to run the full test suite before pushing.
 
 ## Usage with JSON (*not* JSONB) columns
 
-[JSON][pg-json-type] does not provide an [equality operator][pg-json-func].
+**DEPRECATED**: Please migrate to JSONB. It has an equality operator built-in,
+it's faster and stricter, and offers many more indexing abilities and better
+performance than JSON. It is going to be desupported soon because PostgreSQL 10
+does not support these anymore.
+
+The [JSON][pg-json-type] does not provide an [equality operator][pg-json-func].
 As both unnecessary update suppression and selective journaling require
 comparing the OLD and NEW rows fields, this fails by default.
 
-ChronoModel provides a naive JSON equality operator using a naive
-comparison of JSON objects [implemented in pl/python][pg-json-opclass].
+ChronoModel provides a naive and heavyweight JSON equality operator using
+[pl/python][pg-json-opclass] and associated Postgres objects.
 
-To load the opclass you can use the `ChronoModel::Json.create`
-convenience method. If you don't use JSON don't bother doing this.
+To set up you can use
 
-If you are on Postgres 9.4, you are **strongly encouraged to use JSONB**,
-as it has an equality operator built-in, it's faster and stricter, and
-offers many more indexing abilities and better performance than JSON.
+```ruby
+require 'chrono_model/json'
+ChronoModel::Json.create
+```
 
 ## Caveats
 
- * Rails 4 support requires disabling tsrange parsing support, as it
+ * Rails 4+ support requires disabling tsrange parsing support, as it
    [is broken][r4-tsrange-broken] and  [incomplete][r4-tsrange-incomplete]
    as of now, mainly due to a [design clash with ruby][pg-tsrange-and-ruby].
 
@@ -351,8 +377,6 @@ This software is Made in Italy :it: :smile:.
 
 [build-status]: https://travis-ci.org/ifad/chronomodel
 [build-status-badge]: https://travis-ci.org/ifad/chronomodel.svg
-[deps-status]: https://gemnasium.com/ifad/chronomodel
-[deps-status-badge]: https://gemnasium.com/ifad/chronomodel.svg
 [code-analysis]: https://codeclimate.com/github/ifad/chronomodel
 [code-analysis-badge]: https://codeclimate.com/github/ifad/chronomodel.svg
 [docs-analysis]: http://inch-ci.org/github/ifad/chronomodel
@@ -360,7 +384,7 @@ This software is Made in Italy :it: :smile:.
 [test-coverage]: https://codeclimate.com/github/ifad/chronomodel
 [test-coverage-badge]: https://codeclimate.com/github/ifad/chronomodel/badges/coverage.svg
 
-[chronos-image]: http://i.imgur.com/8NObYiZl.jpg
+[delorean-image]: https://i.imgur.com/DD77F4s.jpg
 [rebelle-society]: http://www.rebellesociety.com/2012/10/11/the-writers-way-week-two-facing-procrastination/chronos_oeuvre_grand1/
 
 [wp-scd-2]: http://en.wikipedia.org/wiki/Slowly_changing_dimension#Type_2

data/lib/chrono_model.rb

@@ -1,14 +1,18 @@
-require 'chrono_model/version'
-require 'chrono_model/adapter'
+require 'active_record'
+
+require 'chrono_model/conversions'
 require 'chrono_model/patches'
+require 'chrono_model/adapter'
 require 'chrono_model/time_machine'
 require 'chrono_model/time_gate'
-require 'chrono_model/utils'
+require 'chrono_model/version'
 
 module ChronoModel
   class Error < ActiveRecord::ActiveRecordError #:nodoc:
   end
 
+  # Performs structure upgrade.
+  #
   def self.upgrade!
     connection = ActiveRecord::Base.connection
 
@@ -18,20 +22,44 @@ module ChronoModel
 
     connection.chrono_upgrade!
   end
+
+  # Returns an Hash keyed by table name of ChronoModels.
+  # Computed upon inclusion of the +TimeMachine+ module.
+  #
+  def self.history_models
+    @_history_models||= {}
+  end
 end
 
 if defined?(Rails)
   require 'chrono_model/railtie'
 end
 
+ActiveRecord::Base.instance_eval do
+  # Checks whether this Active Recoed model is backed by a temporal table
+  #
+  def chrono?
+    connection.is_chrono?(table_name)
+  end
+end
+
+# Hooks into Association#scope to pass the As-Of time automatically
+# to methods that load associated ChronoModel records.
+#
 ActiveRecord::Associations::Association.instance_eval do
   prepend ChronoModel::Patches::Association
 end
 
+# Hooks into Relation#build_arel to use :joins on your ChronoModels
+# and join data from associated records As-Of time.
+#
 ActiveRecord::Relation.instance_eval do
   prepend ChronoModel::Patches::Relation
 end
 
+# Hooks in two points of the AR Preloader to preload As-Of time records of
+# associated ChronoModels. is used by .includes, .preload and .eager_load.
+#
 ActiveRecord::Associations::Preloader.instance_eval do
   prepend ChronoModel::Patches::Preloader
 end
@@ -39,3 +67,9 @@ end
 ActiveRecord::Associations::Preloader::Association.instance_eval do
   prepend ChronoModel::Patches::Preloader::Association
 end
+
+if defined?(Rails::DBConsole)
+  Rails::DBConsole.instance_eval do
+    prepend ChronoModel::Patches::DBConsole
+  end
+end

data/lib/chrono_model/adapter.rb

@@ -1,7 +1,10 @@
-require 'active_record'
 require 'active_record/connection_adapters/postgresql_adapter'
 
-require 'multi_json'
+require 'chrono_model/adapter/migrations'
+require 'chrono_model/adapter/ddl'
+require 'chrono_model/adapter/indexes'
+require 'chrono_model/adapter/tsrange'
+require 'chrono_model/adapter/upgrade'
 
 module ChronoModel
 
@@ -10,15 +13,18 @@ module ChronoModel
   # adapter for a clean override of its methods using super.
   #
   class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    include ChronoModel::Adapter::Migrations
+    include ChronoModel::Adapter::DDL
+    include ChronoModel::Adapter::Indexes
+    include ChronoModel::Adapter::TSRange
+    include ChronoModel::Adapter::Upgrade
+
     # The schema holding current data
     TEMPORAL_SCHEMA = 'temporal'
 
     # The schema holding historical data
     HISTORY_SCHEMA  = 'history'
 
-    # This is the data type used for the SCD2 validity
-    RANGE_TYPE = 'tsrange'
-
     # Returns true whether the connection adapter supports our
     # implementation of temporal tables. Currently, Chronomodel
     # is supported starting with PostgreSQL 9.3.
@@ -27,267 +33,37 @@ module ChronoModel
       postgresql_version >= 90300
     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
-        logger.warn "ChronoModel: Temporal Temporal tables require a primary key."
-        logger.warn "ChronoModel: Adding a `__chrono_id' primary key to #{table_name} definition."
-
-        options[:id] = '__chrono_id'
-      end
-
-      transaction do
-        _on_temporal_schema { super }
-        _on_history_schema { chrono_create_history_for(table_name) }
-
-        chrono_create_view_for(table_name, options)
-      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
-        # Rename tables
-        #
-        [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
-
-
-        # Rename indexes on history schema
-        #
-        _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('_') }
-
-          new_names = temporal_index_names(new_name, :validity) +
-            standard_index_names.map {|i| [new_name, i].join('_') }
-
-          old_names.zip(new_names).each do |old, new|
-            execute "ALTER INDEX #{old} RENAME TO #{new}"
-          end
-        end
-
-        # Rename indexes on temporal schema
-        #
-        _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
-
-        # Drop view
-        #
-        execute "DROP VIEW #{name}"
-
-        # Drop functions
-        #
-        chrono_drop_trigger_functions_for(name)
-
-        # Create view and functions
-        #
-        chrono_create_view_for(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
-            #
-            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, options)
-            copy_indexes_to_history_for(table_name)
-
-            # Optionally copy the plain table data, setting up history
-            # retroactively.
-            #
-            if options[:copy_data]
-              seq  = _on_history_schema { serial_sequence(table_name, primary_key(table_name)) }
-              from = options[:validity] || '0001-01-01 00:00:00'
-
-              execute %[
-                INSERT INTO #{HISTORY_SCHEMA}.#{table_name}
-                SELECT *,
-                  nextval('#{seq}')        AS hid,
-                  tsrange('#{from}', NULL) AS validity,
-                  timezone('UTC', now())   AS recorded_at
-                FROM #{TEMPORAL_SCHEMA}.#{table_name}
-              ]
-            end
-          end
-
-          chrono_alter(table_name, options) { 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}"
-
-            chrono_drop_trigger_functions_for(table_name)
-
-            _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
-          end
+    def chrono_setup!
+      chrono_ensure_schemas
 
-          super table_name, options, &block
-        end
-      end
+      chrono_upgrade_warning
     end
 
-    # If dropping a temporal table, drops it from the temporal schema
-    # adding the CASCADE option so to delete the history, view and triggers.
+    # Runs primary_key, indexes and default_sequence_name in the
+    # temporal schema, as the table there defined is the source for
+    # this information.
     #
-    def drop_table(table_name, *)
-      return super unless is_chrono?(table_name)
-
-      _on_temporal_schema { execute "DROP TABLE #{table_name} CASCADE" }
-
-      chrono_drop_trigger_functions_for(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.
+    # Moreover, the PostgreSQLAdapter +indexes+ method uses
+    # current_schema(), thus this is the only (and cleanest) way to
+    # make injection work.
     #
-    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.
+    # 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.
     #
-    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 triggers.
+    # NOTE: These methods are dynamically defined, see the source.
     #
-    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 triggers
-        chrono_create_view_for(table_name)
-      end
+    def primary_key(table_name)
     end
 
-    # If renaming a column of a temporal table, rename it in the table in
-    # the temporal schema and update the triggers.
-    #
-    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 triggers
-        chrono_create_view_for(table_name)
+    [:primary_key, :indexes, :default_sequence_name].each do |method|
+      define_method(method) do |*args|
+        table_name = args.first
+        return super(*args) unless is_chrono?(table_name)
+        on_schema(TEMPORAL_SCHEMA, recurse: :ignore) { super(*args) }
       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 triggers.
-    #
-    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 triggers.
-    #
-    def remove_column(table_name, *)
-      return super unless is_chrono?(table_name)
-      chrono_alter(table_name) { super }
-    end
-
     # Runs column_definitions in the temporal schema, as the table there
     # defined is the source for this information.
     #
@@ -295,256 +71,104 @@ module ChronoModel
     # may reference types defined in other schemas, which result in their
     # names becoming schema qualified, which will cause type resolutions to fail.
     #
-    define_method(:column_definitions) do |table_name|
-      return super(table_name) unless is_chrono?(table_name)
-      on_schema(TEMPORAL_SCHEMA + ',' + self.schema_search_path, false) { super(table_name) }
-    end
-
-    # Runs primary_key, indexes and default_sequence_name 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.
+    # NOTE: This method is dynamically defined, see the source.
     #
-    [:primary_key, :indexes, :default_sequence_name].each do |method|
-      define_method(method) do |*args|
-        table_name = args.first
-        return super(*args) unless is_chrono?(table_name)
-        _on_temporal_schema(false) { super(*args) }
-      end
-    end
-
-    # Create spatial indexes for timestamp search.
-    #
-    # 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
-    #   `range`: the tsrange field
-    #
-    # Options:
-    #
-    #   `:name`: the index name prefix, defaults to
-    #            index_{table}_temporal_on_{range / lower_range / upper_range}
-    #
-    def add_temporal_indexes(table, range, options = {})
-      range_idx, lower_idx, upper_idx =
-        temporal_index_names(table, range, options)
-
-      chrono_alter_index(table, options) do
-        execute <<-SQL
-          CREATE INDEX #{range_idx} ON #{table} USING gist ( #{range} )
-        SQL
-
-        # Indexes used for precise history filtering, sorting and, in history
-        # tables, by UPDATE / DELETE triggers.
-        #
-        execute "CREATE INDEX #{lower_idx} ON #{table} ( lower(#{range}) )"
-        execute "CREATE INDEX #{upper_idx} ON #{table} ( upper(#{range}) )"
-      end
+    def column_definitions
     end
 
-    def remove_temporal_indexes(table, range, options = {})
-      indexes = temporal_index_names(table, range, options)
-
-      chrono_alter_index(table, options) do
-        indexes.each {|idx| execute "DROP INDEX #{idx}" }
-      end
-    end
-
-    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
+    define_method(:column_definitions) do |table_name|
+      return super(table_name) unless is_chrono?(table_name)
+      on_schema(TEMPORAL_SCHEMA + ',' + self.schema_search_path, recurse: :ignore) { super(table_name) }
     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.
+    # Evaluates the given block in the temporal schema.
     #
-    def add_timeline_consistency_constraint(table, range, 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 ( #{id} WITH =, #{range} WITH && )
-        SQL
-      end
-    end
-
-    def remove_timeline_consistency_constraint(table, options = {})
-      name = timeline_consistency_constraint_name(options[:prefix] || table)
-
-      chrono_alter_constraint(table, options) do
-        execute <<-SQL
-          ALTER TABLE #{table} DROP CONSTRAINT #{name}
-        SQL
-      end
+    def on_temporal_schema(&block)
+      on_schema(TEMPORAL_SCHEMA, &block)
     end
 
-    def timeline_consistency_constraint_name(table)
-      "#{table}_timeline_consistency"
+    # Evaluates the given block in the history schema.
+    #
+    def on_history_schema(&block)
+      on_schema(HISTORY_SCHEMA, &block)
     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.
+    # Recursion works by saving the old_path the function closure
+    # at each recursive call.
     #
-    def on_schema(schema, nesting = true, &block)
-      @_on_schema_nesting = (@_on_schema_nesting || 0) + 1
+    # See specs for examples and behaviour.
+    #
+    def on_schema(schema, recurse: :follow)
+      old_path = self.schema_search_path
 
-      if nesting || @_on_schema_nesting == 1
-        old_path = self.schema_search_path
-        self.schema_search_path = schema
-      end
+      count_recursions do
+        if recurse == :follow or Thread.current['recursions'] == 1
+          self.schema_search_path = schema
+        end
 
-      block.call
+        yield
+      end
 
     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.
+      #
+      transaction_aborted =
+        @connection.transaction_status == PG::Connection::PQTRANS_INERROR
 
-        # 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 == PG::Connection::PQTRANS_INERROR
-          @schema_search_path = nil
-        else
-          self.schema_search_path = old_path
-        end
+      if transaction_aborted && Thread.current['recursions'] == 1
+        @schema_search_path = nil
+      else
+        self.schema_search_path = old_path
       end
-      @_on_schema_nesting -= 1
     end
 
     # Returns true if the given name references a temporal table.
     #
     def is_chrono?(table)
-      _on_temporal_schema { chrono_data_source_exists?(table) } &&
-        _on_history_schema { chrono_data_source_exists?(table) }
-
-    rescue ActiveRecord::StatementInvalid => e
-      # means that we could not change the search path to check for
-      # table existence
-      if is_exception_class?(e, PG::InvalidSchemaName, PG::InvalidParameterValue)
-        return false
-      else
-        raise e
-      end
+      on_temporal_schema { data_source_exists?(table) } &&
+        on_history_schema { data_source_exists?(table) }
     end
 
-    def is_exception_class?(e, *klasses)
-      if e.respond_to?(:original_exception)
-        klasses.any? { |k| e.is_a?(k) }
-      else
-        klasses.any? { |k| e.message =~ /#{k.name}/ }
-      end
-    end
-
-    def chrono_setup!
-      chrono_ensure_schemas
-
-      chrono_upgrade_warning
-    end
-
-    def chrono_upgrade!
-      chrono_ensure_schemas
-
-      chrono_upgrade_structure!
-    end
-
-    # HACK: Redefine tsrange parsing support, as it is broken currently.
-    #
-    # This self-made API is here because currently AR4 does not support
-    # open-ended ranges. The reasons are poor support in Ruby:
-    #
-    #   https://bugs.ruby-lang.org/issues/6864
-    #
-    # and an instable interface in Active Record:
+    # Reads the Gem metadata from the COMMENT set on the given PostgreSQL
+    # view name.
     #
-    #   https://github.com/rails/rails/issues/13793
-    #   https://github.com/rails/rails/issues/14010
-    #
-    # so, for now, we are implementing our own.
-    #
-    class TSRange < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range
-      OID = 3908
-
-      def cast_value(value)
-        return if value == 'empty'
-        return value if value.is_a?(::Array)
-
-        extracted = extract_bounds(value)
-
-        from = Conversions.string_to_utc_time extracted[:from]
-        to   = Conversions.string_to_utc_time extracted[:to  ]
+    def chrono_metadata_for(view_name)
+      comment = select_value(
+        "SELECT obj_description(#{quote(view_name)}::regclass)",
+        "ChronoModel metadata for #{view_name}") if data_source_exists?(view_name)
 
-        [from, to]
-      end
-
-      def extract_bounds(value)
-        from, to = value[1..-2].split(',')
-        {
-          from:          (value[1] == ',' || from == '-infinity') ? nil : from[1..-2],
-          to:            (value[-2] == ',' || to == 'infinity') ? nil : to[1..-2],
-        }
-      end
+      MultiJson.load(comment || '{}').with_indifferent_access
     end
 
-    def initialize_type_map(m = type_map)
-      super.tap do
-        ar_type = type_map.fetch(TSRange::OID)
-        cm_type = TSRange.new(ar_type.subtype, ar_type.type)
+    # Writes Gem metadata on the COMMENT field in the given VIEW name.
+    #
+    def chrono_metadata_set(view_name, metadata)
+      comment = MultiJson.dump(metadata)
 
-        type_map.register_type TSRange::OID, cm_type
-      end
+      execute %[ COMMENT ON VIEW #{view_name} IS #{quote(comment)} ]
     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.
-    #
-    # Ref: GitHub pull #21.
-    #
-    def copy_indexes_to_history_for(table_name)
-      history_indexes  = _on_history_schema  { indexes(table_name) }.map(&:name)
-      temporal_indexes = _on_temporal_schema { indexes(table_name) }
+    private
+      # Counts the number of recursions in a thread local variable
+      #
+      def count_recursions # yield
+        Thread.current['recursions'] ||= 0
+        Thread.current['recursions'] += 1
 
-      temporal_indexes.each do |index|
-        next if history_indexes.include?(index.name)
+        yield
 
-        _on_history_schema do
-          execute %[
-            CREATE INDEX #{index.name} ON #{table_name}
-            USING #{index.using} ( #{index.columns.join(', ')} )
-          ], 'Copy index from temporal to history'
-        end
+      ensure
+        Thread.current['recursions'] -= 1
       end
-    end
 
-    private
       # Create the temporal and history schemas, unless they already exist
       #
       def chrono_ensure_schemas
@@ -552,413 +176,6 @@ module ChronoModel
           execute "CREATE SCHEMA #{schema}" unless schema_exists?(schema)
         end
       end
-
-      # Locate tables needing a structure upgrade
-      #
-      def chrono_tables_needing_upgrade
-        tables = { }
-
-        _on_temporal_schema { self.tables }.each do |table_name|
-          next unless is_chrono?(table_name)
-          metadata = chrono_metadata_for(table_name)
-          version = metadata['chronomodel']
-
-          if version.blank?
-            tables[table_name] = { version: nil, priority: 'CRITICAL' }
-          elsif version != VERSION
-            tables[table_name] = { version: version, priority: 'LOW' }
-          end
-        end
-
-        return tables
-      end
-
-      # Emit a warning about tables needing an upgrade
-      #
-      def chrono_upgrade_warning
-        upgrade = chrono_tables_needing_upgrade.map do |table, desc|
-          "#{table} - priority: #{desc[:priority]}"
-        end.join('; ')
-
-        return if upgrade.empty?
-
-        logger.warn "ChronoModel: There are tables needing a structure upgrade, and ChronoModel structures need to be recreated."
-        logger.warn "ChronoModel: Please run ChronoModel.upgrade! to attempt the upgrade. If you have dependant database objects"
-        logger.warn "ChronoModel: the upgrade will fail and you have to drop the dependent objects, run .upgrade! and create them"
-        logger.warn "ChronoModel: again. Sorry. Some features or the whole library may not work correctly until upgrade is complete."
-        logger.warn "ChronoModel: Tables pending upgrade: #{upgrade}"
-      end
-
-      # Upgrades existing structure for each table, if required.
-      #
-      def chrono_upgrade_structure!
-        transaction do
-
-          chrono_tables_needing_upgrade.each do |table_name, desc|
-
-            if desc[:version].blank?
-              logger.info "ChronoModel: Upgrading legacy table #{table_name} to #{VERSION}"
-              upgrade_from_legacy(table_name)
-              logger.info "ChronoModel: legacy #{table_name} upgrade complete"
-            else
-              logger.info "ChronoModel: upgrading #{table_name} from #{desc[:version]} to #{VERSION}"
-              chrono_create_view_for(table_name)
-              logger.info "ChronoModel: #{table_name} upgrade complete"
-            end
-
-          end
-        end
-      rescue => e
-        message = "ChronoModel structure upgrade failed: #{e.message}. Please drop dependent objects first and then run ChronoModel.upgrade! again."
-
-        # Quite important, output it also to stderr.
-        #
-        logger.error message
-        $stderr.puts message
-      end
-
-      def upgrade_from_legacy(table_name)
-        # roses are red
-        # violets are blue
-        # and this is the most boring piece of code ever
-        history_table = "#{HISTORY_SCHEMA}.#{table_name}"
-        p_pkey = primary_key(table_name)
-
-        execute "ALTER TABLE #{history_table} ADD COLUMN validity tsrange;"
-        execute """
-          UPDATE #{history_table} SET validity = tsrange(valid_from,
-            CASE WHEN extract(year from valid_to) = 9999 THEN NULL
-                 ELSE valid_to
-            END
-          );
-        """
-
-        execute "DROP INDEX #{history_table}_temporal_on_valid_from;"
-        execute "DROP INDEX #{history_table}_temporal_on_valid_from_and_valid_to;"
-        execute "DROP INDEX #{history_table}_temporal_on_valid_to;"
-        execute "DROP INDEX #{history_table}_inherit_pkey"
-        execute "DROP INDEX #{history_table}_recorded_at"
-        execute "DROP INDEX #{history_table}_instance_history"
-        execute "ALTER TABLE #{history_table} DROP CONSTRAINT #{table_name}_valid_from_before_valid_to;"
-        execute "ALTER TABLE #{history_table} DROP CONSTRAINT #{table_name}_timeline_consistency;"
-        execute "DROP RULE #{table_name}_upd_first ON #{table_name};"
-        execute "DROP RULE #{table_name}_upd_next ON #{table_name};"
-        execute "DROP RULE #{table_name}_del ON #{table_name};"
-        execute "DROP RULE #{table_name}_ins ON #{table_name};"
-        execute "DROP TRIGGER history_ins ON #{TEMPORAL_SCHEMA}.#{table_name};"
-        execute "DROP FUNCTION #{TEMPORAL_SCHEMA}.#{table_name}_ins();"
-        execute "ALTER TABLE #{history_table} DROP COLUMN valid_from;"
-        execute "ALTER TABLE #{history_table} DROP COLUMN valid_to;"
-
-        execute "CREATE EXTENSION IF NOT EXISTS btree_gist;"
-
-        chrono_create_view_for(table_name)
-        _on_history_schema { add_history_validity_constraint(table_name, p_pkey) }
-        _on_history_schema { chrono_create_history_indexes_for(table_name, p_pkey) }
-      end
-
-      def chrono_metadata_for(table)
-        comment = select_value(
-          "SELECT obj_description(#{quote(table)}::regclass)",
-          "ChronoModel metadata for #{table}") if chrono_data_source_exists?(table)
-
-        MultiJson.load(comment || '{}').with_indifferent_access
-      end
-
-      def chrono_metadata_set(table, metadata)
-        comment = MultiJson.dump(metadata)
-
-        execute %[
-          COMMENT ON VIEW #{table} IS #{quote(comment)}
-        ]
-      end
-
-      def add_history_validity_constraint(table, pkey)
-        add_timeline_consistency_constraint(table, :validity, :id => pkey, :on_current_schema => true)
-      end
-
-      def remove_history_validity_constraint(table, options = {})
-        remove_timeline_consistency_constraint(table, options.merge(:on_current_schema => true))
-      end
-
-      # 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,
-            validity    #{RANGE_TYPE} NOT NULL,
-            recorded_at timestamp NOT NULL DEFAULT timezone('UTC', now())
-          ) INHERITS ( #{parent} )
-        SQL
-
-        add_history_validity_constraint(table, p_pkey)
-
-        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, :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
-
-      # Create the public view and its INSTEAD OF triggers
-      #
-      def chrono_create_view_for(table, options = nil)
-        pk      = primary_key(table)
-        current = [TEMPORAL_SCHEMA, table].join('.')
-        history = [HISTORY_SCHEMA,  table].join('.')
-        seq     = serial_sequence(current, pk)
-
-        options ||= chrono_metadata_for(table)
-
-        # SELECT - return only current data
-        #
-        execute "DROP VIEW #{table}" if chrono_data_source_exists? table
-        execute "CREATE VIEW #{table} AS SELECT * FROM ONLY #{current}"
-
-        # Set default values on the view (closes #12)
-        #
-        chrono_metadata_set(table, options.merge(:chronomodel => VERSION))
-
-        columns(table).each do |column|
-          default = if column.default.nil?
-            column.default_function
-          else
-            if ActiveRecord::VERSION::MAJOR == 4
-              quote(column.default, column)
-            else # Rails 5 and beyond
-              quote(column.default)
-            end
-          end
-
-          next if column.name == pk || default.nil?
-
-          execute "ALTER VIEW #{table} ALTER COLUMN #{quote_column_name(column.name)} SET DEFAULT #{default}"
-        end
-
-        columns = 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(', ')
-
-        # Columns to be journaled. By default everything except updated_at (GH #7)
-        #
-        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)}
-
-        elsif options[:full_journal]
-          columns
-
-        else
-          columns - [ quote_column_name('updated_at') ]
-        end
-
-        journal &= columns
-
-        # 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).
-        #
-        execute <<-SQL
-          CREATE OR REPLACE FUNCTION chronomodel_#{table}_insert() RETURNS TRIGGER AS $$
-            BEGIN
-              IF NEW.#{pk} IS NULL THEN
-                NEW.#{pk} := nextval('#{seq}');
-              END IF;
-
-              INSERT INTO #{current} ( #{pk}, #{fields} )
-              VALUES ( NEW.#{pk}, #{values} );
-
-              INSERT INTO #{history} ( #{pk}, #{fields}, validity )
-              VALUES ( NEW.#{pk}, #{values}, tsrange(timezone('UTC', now()), NULL) );
-
-              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
-
-        # 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.
-        #
-        execute <<-SQL
-          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;
-          $$ 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
-
-        # 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.
-        #
-        execute <<-SQL
-          CREATE OR REPLACE FUNCTION chronomodel_#{table}_delete() RETURNS TRIGGER AS $$
-            DECLARE _now timestamp;
-            BEGIN
-              _now := timezone('UTC', now());
-
-              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);
-
-              DELETE FROM ONLY #{current}
-              WHERE #{pk} = old.#{pk};
-
-              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
-
-      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
-
-      # 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, opts = {})
-        transaction do
-          options = chrono_metadata_for(table_name).merge(opts)
-
-          execute "DROP VIEW #{table_name}"
-
-          _on_temporal_schema { yield }
-
-          # Recreate the triggers
-          chrono_create_view_for(table_name, options)
-        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 chrono_data_source_exists?(table_name)
-        if ActiveRecord::VERSION::MAJOR >= 5
-          data_source_exists?(table_name)
-        else
-          # On Rails 4, table_exists? has the same behaviour, checking if both
-          # a view or table exists
-          table_exists?(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
-
-      def translate_exception(exception, message)
-        if exception.message =~ /conflicting key value violates exclusion constraint/
-          ActiveRecord::RecordNotUnique.new(message)
-        else
-          super
-        end
-      end
   end
 
 end