chrono_model 1.0.1 → 1.1.0

data/lib/chrono_model/time_machine/history_model.rb

@@ -0,0 +1,196 @@
+module ChronoModel
+  module TimeMachine
+
+    module HistoryModel
+      extend ActiveSupport::Concern
+
+      included do
+        self.table_name = [Adapter::HISTORY_SCHEMA, superclass.table_name].join('.')
+
+        scope :chronological, -> { order(Arel.sql('lower(validity) ASC')) }
+      end
+
+      # Methods that make up the history interface of the companion History
+      # model, automatically built for each Model that includes TimeMachine
+      #
+      module ClassMethods
+        include ChronoModel::TimeMachine::TimeQuery
+        include ChronoModel::TimeMachine::Timeline
+
+        # HACK. find() and save() require the real history ID. So we are
+        # setting it now and ensuring to reset it to the original one after
+        # execution completes. FIXME
+        #
+        def with_hid_pkey(&block)
+          old = self.primary_key
+          self.primary_key = :hid
+
+          block.call
+        ensure
+          self.primary_key = old
+        end
+
+        def find(*)
+          with_hid_pkey { super }
+        end
+
+        # In the History context, pre-fill the :on options with the validity interval.
+        #
+        def time_query(match, time, options = {})
+          options[:on] ||= :validity
+          super
+        end
+
+        def past
+          time_query(:before, :now).where("NOT upper_inf(#{quoted_table_name}.validity)")
+        end
+
+        # To identify this class as the History subclass
+        def history?
+          true
+        end
+
+        # Getting the correct quoted_table_name can be tricky when
+        # STI is involved. If Orange < Fruit, then Orange::History < Fruit::History
+        # (see define_inherited_history_model_for).
+        # This means that the superclass method returns Fruit::History, which
+        # will give us the wrong table name. What we actually want is the
+        # superclass of Fruit::History, which is Fruit. So, we use
+        # non_history_superclass instead. -npj
+        def non_history_superclass(klass = self)
+          if klass.superclass.history?
+            non_history_superclass(klass.superclass)
+          else
+            klass.superclass
+          end
+        end
+
+        def relation
+          super.as_of_time!(Time.now)
+        end
+
+        # Fetches as of +time+ records.
+        #
+        def as_of(time)
+          non_history_superclass.from(virtual_table_at(time)).as_of_time!(time)
+        end
+
+        def virtual_table_at(time, name = nil)
+          name = name ? connection.quote_table_name(name) :
+            non_history_superclass.quoted_table_name
+
+          "(#{at(time).to_sql}) #{name}"
+        end
+
+        # Fetches history record at the given time
+        #
+        def at(time)
+          time_query(:at, time).from(quoted_table_name).as_of_time!(time)
+        end
+
+        # Returns the history sorted by recorded_at
+        #
+        def sorted
+          all.order(Arel.sql(%[ #{quoted_table_name}."recorded_at" ASC, #{quoted_table_name}."hid" ASC ]))
+        end
+
+        # Fetches the given +object+ history, sorted by history record time
+        # by default. Always includes an "as_of_time" column that is either
+        # the upper bound of the validity range or now() if history validity
+        # is maximum.
+        #
+        def of(object)
+          where(id: object)
+        end
+      end
+
+      # The history id is `hid`, but this cannot set as primary key
+      # or temporal assocations will break. Solutions are welcome.
+      def id
+        hid
+      end
+
+      # Referenced record ID.
+      #
+      def rid
+        attributes[self.class.primary_key]
+      end
+
+      def save(*)
+        self.class.with_hid_pkey { super }
+      end
+
+      def save!(*)
+        self.class.with_hid_pkey { super }
+      end
+
+      def update_columns(*)
+        self.class.with_hid_pkey { super }
+      end
+
+      # Returns the previous history entry, or nil if this
+      # is the first one.
+      #
+      def pred
+        return if self.valid_from.nil?
+
+        if self.class.timeline_associations.empty?
+          self.class.where('id = ? AND upper(validity) = ?', rid, valid_from).first
+        else
+          super(id: rid, before: valid_from, table: self.class.superclass.quoted_table_name)
+        end
+      end
+
+      # Returns the next history entry, or nil if this is the
+      # last one.
+      #
+      def succ
+        return if self.valid_to.nil?
+
+        if self.class.timeline_associations.empty?
+          self.class.where('id = ? AND lower(validity) = ?', rid, valid_to).first
+        else
+          super(id: rid, after: valid_to, table: self.class.superclass.quoted_table_name)
+        end
+      end
+      alias :next :succ
+
+      # Returns the first history entry
+      #
+      def first
+        self.class.where(id: rid).chronological.first
+      end
+
+      # Returns the last history entry
+      #
+      def last
+        self.class.where(id: rid).chronological.last
+      end
+
+      # Returns this history entry's current record
+      #
+      def current_version
+        self.class.non_history_superclass.find(rid)
+      end
+
+      def record #:nodoc:
+        ActiveSupport::Deprecation.warn '.record is deprecated in favour of .current_version'
+        self.current_version
+      end
+
+      def valid_from
+        validity.first
+      end
+
+      def valid_to
+        validity.last
+      end
+      alias as_of_time valid_to
+
+      def recorded_at
+        ChronoModel::Conversions.string_to_utc_time attributes_before_type_cast['recorded_at']
+      end
+    end
+
+  end
+end

data/lib/chrono_model/time_machine/time_query.rb

@@ -0,0 +1,86 @@
+module ChronoModel
+  module TimeMachine
+
+    #
+    # TODO Documentation
+    #
+    module TimeQuery
+      def time_query(match, time, options)
+        range = columns_hash.fetch(options[:on].to_s)
+
+        where(time_query_sql(match, time, range, options))
+      end
+
+      private
+        def time_query_sql(match, time, range, options)
+          case match
+          when :at
+            build_time_query_at(time, range)
+
+          when :not
+            "NOT (#{build_time_query_at(time, range)})"
+
+          when :before
+            op = options.fetch(:inclusive, true) ? '&&' : '@>'
+            build_time_query(['NULL', time_for_time_query(time, range)], range, op)
+
+          when :after
+            op = options.fetch(:inclusive, true) ? '&&' : '@>'
+            build_time_query([time_for_time_query(time, range), 'NULL'], range, op)
+
+          else
+            raise ChronoModel::Error, "Invalid time_query: #{match}"
+          end
+        end
+
+        def time_for_time_query(t, column)
+          if t == :now || t == :today
+            now_for_column(column)
+          else
+            quoted_t = connection.quote(connection.quoted_date(t))
+            [quoted_t, primitive_type_for_column(column)].join('::')
+          end
+        end
+
+        def now_for_column(column)
+          case column.type
+          when :tsrange, :tstzrange then "timezone('UTC', current_timestamp)"
+          when :daterange           then "current_date"
+          else raise "Cannot generate 'now()' for #{column.type} column #{column.name}"
+          end
+        end
+
+        def primitive_type_for_column(column)
+          case column.type
+          when :tsrange   then :timestamp
+          when :tstzrange then :timestamptz
+          when :daterange then :date
+          else raise "Don't know how to map #{column.type} column #{column.name} to a primitive type"
+          end
+        end
+
+        def build_time_query_at(time, range)
+          time = if time.kind_of?(Array)
+            time.map! {|t| time_for_time_query(t, range)}
+
+            # If both edges of the range are the same the query fails using the '&&' operator.
+            # The correct solution is to use the <@ operator.
+            time.first == time.last ? time.first : time
+          else
+            time_for_time_query(time, range)
+          end
+
+          build_time_query(time, range)
+        end
+
+        def build_time_query(time, range, op = '&&')
+          if time.kind_of?(Array)
+            Arel.sql %[ #{range.type}(#{time.first}, #{time.last}) #{op} #{table_name}.#{range.name} ]
+          else
+            Arel.sql %[ #{time} <@ #{table_name}.#{range.name} ]
+          end
+        end
+    end
+
+  end
+end

data/lib/chrono_model/time_machine/timeline.rb

@@ -0,0 +1,94 @@
+module ChronoModel
+  module TimeMachine
+
+    module Timeline
+      # Returns an Array of unique UTC timestamps for which at least an
+      # history record exists. Takes temporal associations into account.
+      #
+      def timeline(record = nil, options = {})
+        rid = record.respond_to?(:rid) ? record.rid : record.id if record
+
+        assocs = options.key?(:with) ?
+          timeline_associations_from(options[:with]) : timeline_associations
+
+        models = []
+        models.push self if self.chrono?
+        models.concat(assocs.map {|a| a.klass.history})
+
+        return [] if models.empty?
+
+        fields = models.inject([]) {|a,m| a.concat m.quoted_history_fields}
+
+        relation = self.except(:order).
+          select("DISTINCT UNNEST(ARRAY[#{fields.join(',')}]) AS ts")
+
+        if assocs.present?
+          relation = relation.joins(*assocs.map(&:name))
+        end
+
+        relation = relation.
+          order('ts ' << (options[:reverse] ? 'DESC' : 'ASC'))
+
+        relation = relation.from(%["public".#{quoted_table_name}]) unless self.chrono?
+        relation = relation.where(id: rid) if rid
+
+        sql = "SELECT ts FROM ( #{relation.to_sql} ) foo WHERE ts IS NOT NULL"
+
+        if options.key?(:before)
+          sql << " AND ts < '#{Conversions.time_to_utc_string(options[:before])}'"
+        end
+
+        if options.key?(:after)
+          sql << " AND ts > '#{Conversions.time_to_utc_string(options[:after ])}'"
+        end
+
+        if rid && !options[:with]
+          sql << (self.chrono? ? %{
+            AND ts <@ ( SELECT tsrange(min(lower(validity)), max(upper(validity)), '[]') FROM #{quoted_table_name} WHERE id = #{rid} )
+          } : %[ AND ts < NOW() ])
+        end
+
+        sql << " LIMIT #{options[:limit].to_i}" if options.key?(:limit)
+
+        sql.gsub! 'INNER JOIN', 'LEFT OUTER JOIN'
+
+        connection.on_schema(Adapter::HISTORY_SCHEMA) do
+          connection.select_values(sql, "#{self.name} periods").map! do |ts|
+            Conversions.string_to_utc_time ts
+          end
+        end
+      end
+
+      def has_timeline(options)
+        options.assert_valid_keys(:with)
+
+        timeline_associations_from(options[:with]).tap do |assocs|
+          timeline_associations.concat assocs
+        end
+      end
+
+      def timeline_associations
+        @timeline_associations ||= []
+      end
+
+      def timeline_associations_from(names)
+        Array.wrap(names).map do |name|
+          reflect_on_association(name) or raise ArgumentError,
+            "No association found for name `#{name}'"
+        end
+      end
+
+      def quoted_history_fields
+        @quoted_history_fields ||= begin
+          validity =
+            [connection.quote_table_name(table_name),
+             connection.quote_column_name('validity')
+            ].join('.')
+
+          [:lower, :upper].map! {|func| "#{func}(#{validity})"}
+        end
+      end
+    end
+
+  end
+end

data/lib/chrono_model/utilities.rb

@@ -0,0 +1,27 @@
+module ChronoModel
+
+  module Utilities
+    # Amends the given history item setting a different period.
+    # Useful when migrating from legacy systems.
+    #
+    # To use it, extend AR::Base with ChronoModel::Utilities
+    #
+    #   ActiveRecord::Base.instance_eval do
+    #     extend ChronoModel::Utilities
+    #   end
+    #
+    def amend_period!(hid, from, to)
+      unless [from, to].any? {|ts| ts.respond_to?(:zone) && ts.zone == 'UTC'}
+        raise 'Can amend history only with UTC timestamps'
+      end
+
+      connection.execute %[
+        UPDATE #{quoted_table_name}
+           SET "validity" = tsrange(#{connection.quote(from)}, #{connection.quote(to)}),
+               "recorded_at" = #{connection.quote(from)}
+         WHERE "hid" = #{hid.to_i}
+      ]
+    end
+  end
+
+end

data/lib/chrono_model/version.rb

@@ -1,3 +1,3 @@
 module ChronoModel
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/aruba/dbconsole_spec.rb

@@ -0,0 +1,25 @@
+# The db consle does not work on Rails 5.0
+#
+unless Bundler.default_gemfile.to_s =~ /rails_5.0/
+
+
+require 'spec_helper'
+
+describe 'rails dbconsole' do
+  before do
+    write_file(
+      'config/database.yml',
+      File.read(File.expand_path('fixtures/database_without_username_and_password.yml', __dir__)))
+  end
+
+  describe 'rails dbconsole', type: :aruba do
+    let(:action) { run_command("bash -c \"echo 'select 1 as foo_column; \\q' | bundle exec rails db\"") }
+    let(:last_command) { action && last_command_started }
+
+    specify { expect(last_command).to be_successfully_executed }
+    specify { expect(last_command).to have_output(/\bfoo_column\b/) }
+  end
+end
+
+
+end

data/spec/chrono_model/adapter/counter_cache_race_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'support/helpers'
+
+describe 'models with counter cache' do
+  include ChronoTest::Helpers::TimeMachine
+
+    adapter.create_table 'sections', temporal: true, no_journal: %w( articles_count ) do |t|
+      t.string :name
+      t.integer :articles_count, default: 0
+    end
+
+    adapter.create_table 'articles', temporal: true do |t|
+      t.string :title
+      t.references :section
+    end
+
+  class ::Section < ActiveRecord::Base
+    include ChronoModel::TimeMachine
+
+    has_many :articles
+  end
+
+  class ::Article < ActiveRecord::Base
+    include ChronoModel::TimeMachine
+
+    belongs_to :section, counter_cache: true
+  end
+
+  describe 'are not subject to race condition if no_journal is set on the counter cache column' do
+    specify do
+      section = Section.create!
+
+      expect(section.articles_count).to eq(0)
+      Article.create!(section_id: section.id)
+      expect(section.reload.articles_count).to eq(1)
+
+      num_threads = 10
+
+      expect {
+        Array.new(num_threads).map do
+          Thread.new { Article.create!(section_id: section.id) }
+        end.each(&:join)
+      }.to_not raise_error
+    end
+  end
+end