chrono_model 1.0.1 → 1.1.0

data/lib/chrono_model/adapter/tsrange.rb

@@ -0,0 +1,57 @@
+module ChronoModel
+  class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+
+    module TSRange
+      # 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:
+      #
+      #   https://github.com/rails/rails/issues/13793
+      #   https://github.com/rails/rails/issues/14010
+      #
+      # so, for now, we are implementing our own.
+      #
+      class Type < 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  ]
+
+          [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
+      end
+
+      def initialize_type_map(m = type_map)
+        super.tap do
+          typ = ChronoModel::Adapter::TSRange::Type
+          oid = typ::OID
+
+          ar_type = type_map.fetch(oid)
+          cm_type = typ.new(ar_type.subtype, ar_type.type)
+
+          type_map.register_type oid, cm_type
+        end
+      end
+    end
+
+  end
+end

data/lib/chrono_model/adapter/upgrade.rb

@@ -0,0 +1,120 @@
+module ChronoModel
+  class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+
+    module Upgrade
+      private
+        def chrono_upgrade!
+          chrono_ensure_schemas
+
+          chrono_upgrade_structure!
+        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 PG 9.0 table #{table_name} to #{VERSION}"
+                chrono_upgrade_from_postgres_9_0(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 chrono_upgrade_from_postgres_9_0(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
+      # private
+    end
+
+  end
+
+end

data/lib/chrono_model/conversions.rb

@@ -0,0 +1,20 @@
+module ChronoModel
+
+  module Conversions
+    extend self
+
+    ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(?:\.(\d+))?\z/
+
+    def string_to_utc_time(string)
+      if string =~ ISO_DATETIME
+        usec = $7.nil? ? '000000' : $7.ljust(6, '0') # .1 is .100000, not .000001
+        Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec.to_i
+      end
+    end
+
+    def time_to_utc_string(time)
+      [time.to_s(:db), sprintf('%06d', time.usec)].join '.'
+    end
+  end
+
+end

data/lib/chrono_model/json.rb

@@ -0,0 +1,28 @@
+module ChronoModel
+
+  module Json
+    extend self
+
+    def create
+      puts "ChronoModel: WARNING - JSON ops are deprecated. Please migrate to JSONB"
+
+      adapter.execute 'CREATE OR REPLACE LANGUAGE plpythonu'
+      adapter.execute File.read(sql 'json_ops.sql')
+    end
+
+    def drop
+      adapter.execute File.read(sql 'uninstall-json_ops.sql')
+      adapter.execute 'DROP LANGUAGE IF EXISTS plpythonu'
+    end
+
+    private
+    def sql(file)
+      File.dirname(__FILE__) + '/../../sql/' + file
+    end
+
+    def adapter
+      ActiveRecord::Base.connection
+    end
+  end
+
+end

data/lib/chrono_model/patches.rb

@@ -1,232 +1,8 @@
-require 'active_record'
-
-module ChronoModel
-  module Patches
-
-    module AsOfTimeHolder
-      # Sets the virtual 'as_of_time' attribute to the given time, converting to UTC.
-      #
-      def as_of_time!(time)
-        @_as_of_time = time.utc
-
-        self
-      end
-
-      # Reads the virtual 'as_of_time' attribute
-      #
-      def as_of_time
-        @_as_of_time
-      end
-    end
-
-    # This class supports the AR 5.0 code that expects to receive an
-    # Arel::Table as the left join node. We need to replace the node
-    # with a virtual table that fetches from the history at a given
-    # point in time, we replace the join node with a SqlLiteral node
-    # that does not respond to the methods that AR expects.
-    #
-    # This class provides AR with an object implementing the methods
-    # it expects, yet producing SQL that fetches from history tables
-    # as-of-time.
-    #
-    class JoinNode < Arel::Nodes::SqlLiteral
-      attr_reader :name, :table_name, :table_alias, :as_of_time
-
-      def initialize(join_node, history_model, as_of_time)
-        @name        = join_node.table_name
-        @table_name  = join_node.table_name
-        @table_alias = join_node.table_alias
-
-        @as_of_time  = as_of_time
-
-        virtual_table = history_model.
-          virtual_table_at(@as_of_time, @table_alias || @table_name)
-
-        super(virtual_table)
-      end
-    end
-
-    module Relation
-      include AsOfTimeHolder
-
-      def load
-        return super unless @_as_of_time && !loaded?
-
-        super.each {|record| record.as_of_time!(@_as_of_time) }
-      end
-
-      def merge(*)
-        return super unless @_as_of_time
-
-        super.as_of_time!(@_as_of_time)
-      end
-
-      def build_arel(*)
-        return super unless @_as_of_time
-
-        super.tap do |arel|
-
-          arel.join_sources.each do |join|
-            # This case happens with nested includes, where the below
-            # code has already replaced the join.left with a JoinNode.
-            #
-            next if join.left.respond_to?(:as_of_time)
-
-            model = TimeMachine.chrono_models[join.left.table_name]
-            next unless model
-
-            join.left = JoinNode.new(join.left, model.history, @_as_of_time)
-          end
-
-        end
-      end
-
-      # Build a preloader at the +as_of_time+ of this relation.
-      # Pass the current model to define Relation
-      #
-      def build_preloader
-        ActiveRecord::Associations::Preloader.new(
-          model: self.model, as_of_time: as_of_time
-        )
-      end
-    end
-
-    # This class is a dummy relation whose scope is only to pass around the
-    # as_of_time parameters across ActiveRecord call chains.
-    #
-    # With AR 5.2 a simple relation can be used, as the only required argument
-    # is the model. 5.0 and 5.1 require more arguments, that are passed here.
-    #
-    class AsOfTimeRelation < ActiveRecord::Relation
-      if ActiveRecord::VERSION::STRING.to_f < 5.2
-        def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
-          super(klass, table, predicate_builder, values)
-        end
-      end
-    end
-
-    # Patches ActiveRecord::Associations::Preloader to add support for
-    # temporal associations. This is tying itself to Rails internals
-    # and it is ugly :-(.
-    #
-    module Preloader
-      attr_reader :options
-
-      # We overwrite the initializer in order to pass the +as_of_time+
-      # parameter above in the build_preloader
-      #
-      def initialize(options = {})
-        @options = options.freeze
-      end
-
-      # Patches the AR Preloader (lib/active_record/associations/preloader.rb)
-      # in order to carry around the +as_of_time+ of the original invocation.
-      #
-      # * The +records+ are the parent records where the association is defined
-      # * The +associations+ are the association names involved in preloading
-      # * The +given_preload_scope+ is the preloading scope, that is used only
-      #   in the :through association and it holds the intermediate records
-      #   _through_ which the final associated records are eventually fetched.
-      #
-      # As the +preload_scope+ is passed around to all the different
-      # incarnations of the preloader strategies, we are using it to pass
-      # around the +as_of_time+ of the original query invocation, so that
-      # preloaded records are preloaded honoring the +as_of_time+.
-      #
-      # The +preload_scope+ is present only in through associations, but the
-      # preloader interfaces expect it to be always defined, for consistency.
-      #
-      # For `:through` associations, the +given_preload_scope+ is already a
-      # +Relation+, that already has the +as_of_time+ getters and setters,
-      # so we use it directly.
-      #
-      def preload(records, associations, given_preload_scope = nil)
-        if options[:as_of_time]
-          preload_scope = given_preload_scope ||
-            AsOfTimeRelation.new(options[:model])
-
-          preload_scope.as_of_time!(options[:as_of_time])
-        end
-
-        super records, associations, preload_scope
-      end
-
-      module Association
-        # Builds the preloader scope taking into account a potential
-        # +as_of_time+ passed down the call chain starting at the
-        # end user invocation.
-        #
-        def build_scope
-          scope = super
-
-          if preload_scope.try(:as_of_time)
-            scope = scope.as_of(preload_scope.as_of_time)
-          end
-
-          return scope
-        end
-      end
-    end
-
-    # Patches ActiveRecord::Associations::Association to add support for
-    # temporal associations.
-    #
-    # Each record fetched from the +as_of+ scope on the owner class will have
-    # an additional "as_of_time" field yielding the UTC time of the request,
-    # then the as_of scope is called on either this association's class or
-    # on the join model's (:through association) one.
-    #
-    module Association
-      def skip_statement_cache?(*)
-        super || _chrono_target?
-      end
-
-      # If the association class or the through association are ChronoModels,
-      # then fetches the records from a virtual table using a subquery scope
-      # to a specific timestamp.
-      def scope
-        scope = super
-        return scope unless _chrono_record?
-
-        if _chrono_target?
-          # For standard associations, replace the table name with the virtual
-          # as-of table name at the owner's as-of-time
-          #
-          scope = scope.from(klass.history.virtual_table_at(owner.as_of_time))
-        elsif respond_to?(:through_reflection) && through_reflection.klass.chrono?
-
-          # For through associations, replace the joined table name instead
-          # with a virtual table that selects records from the history at
-          # the given +as_of_time+.
-          #
-          scope.join_sources.each do |join|
-            if join.left.name == through_reflection.klass.table_name
-              history_model = through_reflection.klass.history
-
-              join.left = JoinNode.new(join.left, history_model, owner.as_of_time)
-            end
-          end
-        end
-
-        scope.as_of_time!(owner.as_of_time)
-
-        return scope
-      end
-
-      private
-        def _chrono_record?
-          owner.respond_to?(:as_of_time) && owner.as_of_time.present?
-        end
-
-        def _chrono_target?
-          @_target_klass ||= reflection.options[:polymorphic] ?
-            owner.public_send(reflection.foreign_type).constantize :
-            reflection.klass
-
-          @_target_klass.chrono?
-        end
-
-    end
-
-  end
-end
+require 'chrono_model/patches/as_of_time_holder'
+require 'chrono_model/patches/as_of_time_relation'
+
+require 'chrono_model/patches/join_node'
+require 'chrono_model/patches/relation'
+require 'chrono_model/patches/preloader'
+require 'chrono_model/patches/association'
+require 'chrono_model/patches/db_console'