chrono_model 0.5.3 → 0.8.0

data/lib/chrono_model/patches.rb

@@ -14,11 +14,11 @@ module ChronoModel
     class Association < ActiveRecord::Associations::Association
 
       # If the association class or the through association are ChronoModels,
-      # then fetches the records from a virtual table using a subquery scoped
+      # then fetches the records from a virtual table using a subquery scope
       # to a specific timestamp.
-      def scoped
-        scoped = super
-        return scoped unless _chrono_record?
+      def scope
+        scope = super
+        return scope unless _chrono_record?
 
         klass = reflection.options[:polymorphic] ?
           owner.public_send(reflection.foreign_type).constantize :
@@ -28,23 +28,36 @@ module ChronoModel
           # For standard associations, replace the table name with the virtual
           # as-of table name at the owner's as-of-time
           #
-          scoped = scoped.readonly.from(klass.history.virtual_table_at(owner.as_of_time))
+          scope = scope.readonly.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.
           #
-          scoped.join_sources.each do |join|
+          scope.join_sources.each do |join|
             if join.left.name == through_reflection.klass.table_name
               v_table = through_reflection.klass.history.virtual_table_at(
                 owner.as_of_time, join.left.table_alias || join.left.table_name)
 
-              join.left = Arel::Nodes::SqlLiteral.new(v_table)
+              # avoid problems in Rails when code down the line expects the
+              # join.left to respond to the following methods. we modify
+              # the instance of SqlLiteral to do just that.
+              table_name  = join.left.table_name
+              table_alias = join.left.table_alias
+              join.left   = Arel::Nodes::SqlLiteral.new(v_table)
+
+              class << join.left
+                attr_accessor :name, :table_name, :table_alias
+              end
+
+              join.left.name        = table_name
+              join.left.table_name  = table_name
+              join.left.table_alias = table_alias
             end
           end
 
         end
 
-        return scoped
+        return scope
       end
 
       private

data/lib/chrono_model/railtie.rb

@@ -1,21 +1,9 @@
 module ChronoModel
   class Railtie < ::Rails::Railtie
-    initializer :chrono_create_schemas do
-      ActiveRecord::Base.connection.chrono_create_schemas!
-    end
+    ActiveRecord::Tasks::DatabaseTasks.register_task /chronomodel/, ActiveRecord::Tasks::PostgreSQLDatabaseTasks
 
     rake_tasks do
       load 'chrono_model/schema_format.rake'
-
-      namespace :db do
-        namespace :chrono do
-          task :create_schemas do
-            ActiveRecord::Base.connection.chrono_create_schemas!
-          end
-        end
-      end
-
-      task 'db:schema:load' => 'db:chrono:create_schemas'
     end
   end
 end

data/lib/chrono_model/time_gate.rb

@@ -11,10 +11,10 @@ module ChronoModel
         time = Conversions.time_to_utc_string(time.utc) if time.kind_of? Time
 
         virtual_table = select(%[
-          #{quoted_table_name}.*, #{connection.quote(time)} AS "as_of_time"]
+          #{quoted_table_name}.*, #{connection.quote(time)}::timestamp AS "as_of_time"]
         ).to_sql
 
-        as_of = scoped.from("(#{virtual_table}) #{quoted_table_name}")
+        as_of = all.from("(#{virtual_table}) #{quoted_table_name}")
 
         as_of.instance_variable_set(:@temporal, time)
 

data/lib/chrono_model/time_machine.rb

@@ -6,11 +6,6 @@ module ChronoModel
     extend ActiveSupport::Concern
 
     included do
-      unless supports_chrono?
-        raise Error, "Your database server is not supported by ChronoModel. "\
-          "Currently, only PostgreSQL >= 9.0 is supported."
-      end
-
       if table_exists? && !chrono?
         puts "WARNING: #{table_name} is not a temporal table. " \
           "Please use change_table :#{table_name}, :temporal => true"
@@ -51,7 +46,7 @@ module ChronoModel
           hid
         end
 
-        # Referenced record ID
+        # Referenced record ID.
         #
         def rid
           attributes[self.class.primary_key]
@@ -72,12 +67,12 @@ module ChronoModel
         # is the first one.
         #
         def pred
-          return nil if self.valid_from.year.zero?
+          return if self.valid_from.nil?
 
           if self.class.timeline_associations.empty?
-            self.class.where(:id => rid, :valid_to => valid_from_before_type_cast).first
+            self.class.where('id = ? AND upper(validity) = ?', rid, valid_from).first
           else
-            super(:id => rid, :before => valid_from)
+            super(:id => rid, :before => valid_from, :table => self.class.superclass.quoted_table_name)
           end
         end
 
@@ -85,12 +80,12 @@ module ChronoModel
         # last one.
         #
         def succ
-          return nil if self.valid_to.year == 9999
+          return if self.valid_to.nil?
 
           if self.class.timeline_associations.empty?
-            self.class.where(:id => rid, :valid_from => valid_to_before_type_cast).first
+            self.class.where('id = ? AND lower(validity) = ?', rid, valid_to).first
           else
-            super(:id => rid, :after => valid_to)
+            super(:id => rid, :after => valid_to, :table => self.class.superclass.quoted_table_name)
           end
         end
         alias :next :succ
@@ -98,13 +93,13 @@ module ChronoModel
         # Returns the first history entry
         #
         def first
-          self.class.where(:id => rid).order(:valid_from).first
+          self.class.where(:id => rid).order('lower(validity)').first
         end
 
         # Returns the last history entry
         #
         def last
-          self.class.where(:id => rid).order(:valid_from).last
+          self.class.where(:id => rid).order('lower(validity)').last
         end
 
         # Returns this history entry's current record
@@ -112,6 +107,18 @@ module ChronoModel
         def record
           self.class.superclass.find(rid)
         end
+
+        def valid_from
+          validity.first
+        end
+
+        def valid_to
+          validity.last
+        end
+
+        def recorded_at
+          Conversions.string_to_utc_time attributes_before_type_cast['recorded_at']
+        end
       end
 
       model.singleton_class.instance_eval do
@@ -188,15 +195,10 @@ module ChronoModel
       self.attributes.key?('as_of_time') || self.kind_of?(self.class.history)
     end
 
-    # Hack around AR timezone support. These timestamps are recorded
-    # by the chrono rewrite rules in UTC, but AR reads them as they
-    # were stored in the local timezone - thus here we bypass type
-    # casting to force creation of UTC timestamps.
+    # Read the virtual 'as_of_time' attribute and return it as an UTC timestamp.
     #
-    %w( valid_from valid_to recorded_at as_of_time ).each do |attr|
-      define_method(attr) do
-        Conversions.string_to_utc_time attributes_before_type_cast[attr]
-      end
+    def as_of_time
+      Conversions.string_to_utc_time attributes_before_type_cast['as_of_time']
     end
 
     # Inhibit destroy of historical records
@@ -211,10 +213,10 @@ module ChronoModel
     #
     def pred(options = {})
       if self.class.timeline_associations.empty?
-        history.order('valid_to DESC').offset(1).first
+        history.order('upper(validity) DESC').offset(1).first
       else
         return nil unless (ts = pred_timestamp(options))
-        self.class.as_of(ts).order('hid desc').find(options[:id] || id)
+        self.class.as_of(ts).order(%[ #{options[:table] || self.class.quoted_table_name}."hid" DESC ]).find(options[:id] || id)
       end
     end
 
@@ -235,7 +237,7 @@ module ChronoModel
     def succ(options = {})
       unless self.class.timeline_associations.empty?
         return nil unless (ts = succ_timestamp(options))
-        self.class.as_of(ts).order('hid desc').find(options[:id] || id)
+        self.class.as_of(ts).order(%[ #{options[:table] || self.class.quoted_table_name}."hid" DESC ]).find(options[:id] || id)
       end
     end
 
@@ -275,13 +277,6 @@ module ChronoModel
       end
     end
 
-    # Wraps AR::Base#attributes by removing the __xid internal attribute
-    # used to squash together changes made in the same transaction.
-    #
-    %w( attributes attribute_names ).each do |name|
-      define_method(name) { super().tap {|x| x.delete('__xid')} }
-    end
-
     module ClassMethods
       # Returns an ActiveRecord::Relation on the history of this model as
       # it was +time+ ago.
@@ -291,7 +286,7 @@ module ChronoModel
 
       def attribute_names_for_history_changes
         @attribute_names_for_history_changes ||= attribute_names -
-          %w( id hid valid_from valid_to recorded_at as_of_time )
+          %w( id hid validity recorded_at as_of_time )
       end
 
       def has_timeline(options)
@@ -308,48 +303,76 @@ module ChronoModel
     end
 
     module TimeQuery
-      OPERATORS = {
-        :at      => '&&',
-        :before  => '<<',
-        :after   => '>>',
-      }.freeze
+      # TODO Documentation
+      #
+      def time_query(match, time, options)
+        range = columns_hash.fetch(options[:on].to_s)
 
-      def time_query(match, time_or_times, options)
-        from_f, to_f = options[:on]
+        query = case match
+        when :at
+          build_time_query_at(time, range)
 
-        from_t, to_t = if time_or_times.kind_of?(Array)
-          time_or_times.map! {|t| time_for_time_query(t)}
-        else
-          [time_for_time_query(time_or_times)]*2
-        end
+        when :not
+          "NOT (#{build_time_query_at(time, range)})"
+
+        when :before
+          build_time_query(['NULL', time_for_time_query(time, range)], range)
+
+        when :after
+          build_time_query([time_for_time_query(time, range), 'NULL'], range)
 
-        if match == :not
-          where(%[
-            #{build_time_query(:before, from_t, from_f, to_t, to_f)} OR
-            #{build_time_query(:after,  from_t, from_f, to_t, to_f)}
-          ])
         else
-          where(build_time_query(match, from_t, from_f, to_t, to_f))
+          raise ArgumentError, "Invalid time_query: #{match}"
         end
+
+        where(query)
       end
 
       private
-        def time_for_time_query(t)
-          t = Conversions.time_to_utc_string(t.utc) if t.kind_of?(Time)
-          t == :now ? 'now()' : "#{connection.quote(t)}::timestamp"
+
+        def time_for_time_query(t, column)
+          if t == :now || t == :today
+            now_for_column(column)
+          else
+            [connection.quote(t, column),
+             primitive_type_for_column(column)
+            ].join('::')
+          end
         end
 
-        def build_time_query(match, from_t, from_f, to_t, to_f)
-          %[
-            box(
-              point( date_part( 'epoch', #{from_f} ), 0 ),
-              point( date_part( 'epoch', #{to_f  } ), 0 )
-            ) #{OPERATORS.fetch(match)}
-            box(
-              point( date_part( 'epoch', #{from_t} ), 0 ),
-              point( date_part( 'epoch', #{to_t  } ), 0 )
-            )
-          ]
+        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)}
+          else
+            time_for_time_query(time, range)
+          end
+
+          build_time_query(time, range)
+        end
+
+        def build_time_query(time, range)
+          if time.kind_of?(Array)
+            %[ #{range.type}(#{time.first}, #{time.last}) && #{table_name}.#{range.name} ]
+          else
+            %[ #{time} <@ #{table_name}.#{range.name} ]
+          end
         end
     end
 
@@ -358,10 +381,41 @@ module ChronoModel
     module HistoryMethods
       include TimeQuery
 
+      # 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(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.respond_to?(:history?) && klass.superclass.history?
+          non_history_superclass(klass.superclass)
+        else
+          klass.superclass
+        end
+      end
+
       # Fetches as of +time+ records.
       #
       def as_of(time, scope = nil)
-        as_of = superclass.unscoped.readonly.from(virtual_table_at(time))
+        as_of = non_history_superclass.unscoped.readonly.from(virtual_table_at(time))
 
         # Add default scopes back if we're passed nil or a
         # specific scope, because we're .unscopeing above.
@@ -383,7 +437,7 @@ module ChronoModel
 
       def virtual_table_at(time, name = nil)
         name = name ? connection.quote_table_name(name) :
-          superclass.quoted_table_name
+          non_history_superclass.quoted_table_name
 
         "(#{at(time).to_sql}) #{name}"
       end
@@ -391,23 +445,29 @@ module ChronoModel
       # Fetches history record at the given time
       #
       def at(time)
-        time = Conversions.time_to_utc_string(time.utc) if time.kind_of?(Time)
+        time = Conversions.time_to_utc_string(time.utc) if time.kind_of?(Time) && !time.utc?
 
         unscoped.
-          select("#{quoted_table_name}.*, #{connection.quote(time)} AS as_of_time").
-          time_query(:at, time, :on => quoted_history_fields)
+          select("#{quoted_table_name}.*, #{connection.quote(time)}::timestamp AS as_of_time").
+          time_query(:at, time)
       end
 
       # Returns the whole history as read only.
       #
       def all
-        readonly.
-          order("#{quoted_table_name}.recorded_at, hid").all
+        super.readonly
+      end
+
+      # Returns the history sorted by recorded_at
+      #
+      def sorted
+        all.order(%[ #{quoted_table_name}."recorded_at", #{quoted_table_name}."hid" ])
       end
 
       # Fetches the given +object+ history, sorted by history record time
       # by default. Always includes an "as_of_time" column that is either
-      # the valid_to timestamp or now() if history validity is maximum.
+      # the upper bound of the validity range or now() if history validity
+      # is maximum.
       #
       def of(object)
         readonly.where(:id => object).extend(HistorySelect)
@@ -425,11 +485,11 @@ module ChronoModel
           return super if has_aggregate
 
           if order_values.blank?
-            self.order_values += ["#{quoted_table_name}.recorded_at, #{quoted_table_name}.hid"]
+            self.order_values += [ %[#{quoted_table_name}."recorded_at", #{quoted_table_name}."hid"] ]
           end
 
           super.tap do |rel|
-            rel.project("LEAST(valid_to, now()::timestamp) AS as_of_time")
+            rel.project("LEAST(upper(validity), timezone('UTC', now())) AS as_of_time")
           end
         end
       end
@@ -451,11 +511,15 @@ module ChronoModel
           return [] if models.empty?
 
           fields = models.inject([]) {|a,m| a.concat m.quoted_history_fields}
-          fields.map! {|f| "#{f} + INTERVAL '2 usec'"}
 
           relation = self.
-            joins(*assocs.map(&:name)).
-            select("DISTINCT UNNEST(ARRAY[#{fields.join(',')}]) AS ts").
+            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?
@@ -471,11 +535,10 @@ module ChronoModel
             sql << " AND ts > '#{Conversions.time_to_utc_string(options[:after ])}'"
           end
 
-          if rid
-            sql << (self.chrono? ? %[
-              AND ts >= ( SELECT MIN(valid_from) FROM #{quoted_table_name} WHERE id = #{rid} )
-              AND ts <  ( SELECT MAX(valid_to  ) FROM #{quoted_table_name} WHERE id = #{rid} )
-            ] : %[ AND ts < NOW() ])
+          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)
@@ -510,10 +573,13 @@ module ChronoModel
       end)
 
       def quoted_history_fields
-        @quoted_history_fields ||= [:valid_from, :valid_to].map do |field|
-          [connection.quote_table_name(table_name),
-           connection.quote_column_name(field)
-          ].join('.')
+        @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