activerecord-temporal 0.1.0 → 0.2.0

data/lib/activerecord/temporal/querying/scoping.rb

@@ -0,0 +1,70 @@
+module ActiveRecord::Temporal
+  module Querying
+    class Scoping
+      class << self
+        def at(time_or_time_coords, &block)
+          if time_or_time_coords.is_a?(Hash)
+            with_global_constraint(time_or_time_coords, &block)
+          else
+            without_global_constraints do
+              with_universal_global_constraint_time(time_or_time_coords, &block)
+            end
+          end
+        end
+
+        def as_of(time_coords, &block)
+          with_association_constraints(time_coords) do
+            with_association_tags(time_coords, &block)
+          end
+        end
+
+        private
+
+        def with_association_constraints(time_coords, &block)
+          original = ScopeRegistry.association_constraints
+          ScopeRegistry.set_association_constraints(time_coords)
+
+          block.call
+        ensure
+          ScopeRegistry.association_constraints = original
+        end
+
+        def with_association_tags(time_coords, &block)
+          original = ScopeRegistry.association_tags
+          ScopeRegistry.set_association_tags(time_coords)
+
+          block.call
+        ensure
+          ScopeRegistry.association_tags = original
+        end
+
+        def with_global_constraint(value, &block)
+          original = ScopeRegistry.global_constraints
+          ScopeRegistry.set_global_constraints(value)
+
+          block.call
+        ensure
+          ScopeRegistry.global_constraints = original
+        end
+
+        def without_global_constraints(&block)
+          original = ScopeRegistry.global_constraints
+          ScopeRegistry.global_constraints = {}
+
+          block.call
+        ensure
+          ScopeRegistry.global_constraints = original
+        end
+
+        def with_universal_global_constraint_time(time, &block)
+          original = ScopeRegistry.universal_global_constraint_time
+          ScopeRegistry.universal_global_constraint_time = time
+
+          block.call
+        ensure
+          ScopeRegistry.universal_global_constraint_time = original
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/{as_of_query → querying}/time_dimensions.rb

@@ -1,5 +1,5 @@
 module ActiveRecord::Temporal
-  module AsOfQuery
+  module Querying
     module TimeDimensions
       extend ActiveSupport::Concern
 
@@ -8,7 +8,9 @@ module ActiveRecord::Temporal
       end
 
       class_methods do
-        def set_time_dimensions(*dimensions)
+        def time_dimensions=(*dimensions)
+          dimensions = dimensions.flatten
+
           define_singleton_method(:time_dimensions) { dimensions }
           define_singleton_method(:default_time_dimension) { dimensions.first }
         end
@@ -17,7 +19,15 @@ module ActiveRecord::Temporal
         def default_time_dimension = nil
 
         def time_dimension_column?(time_dimension)
-          connection.column_exists?(table_name, time_dimension)
+          @time_dimension_column_cache ||= {}
+
+          @time_dimension_column_cache[time_dimension] ||= connection.column_exists?(table_name, time_dimension)
+        end
+
+        def time_dimension_columns
+          time_dimensions.select do |dimension|
+            time_dimension_column?(dimension)
+          end
         end
       end
 

data/lib/activerecord/temporal/querying/where_clause_refinement.rb

@@ -0,0 +1,17 @@
+module ActiveRecord::Temporal
+  module Querying
+    module WhereClauseRefinement
+      refine ActiveRecord::Relation::WhereClause do
+        def except_contains(columns)
+          columns = columns.map(&:to_s)
+
+          remaining_predications = predicates.reject do |node|
+            node.is_a?(Arel::Nodes::Contains) && columns.include?(node.left.name)
+          end
+
+          self.class.new(remaining_predications)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/querying.rb

@@ -0,0 +1,95 @@
+module ActiveRecord::Temporal
+  module Querying
+    class RangeError < StandardError; end
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def resolve_time_coords(time_or_time_coords)
+        return time_or_time_coords if time_or_time_coords.is_a?(Hash)
+
+        {default_time_dimension.to_sym => time_or_time_coords}
+      end
+    end
+
+    included do
+      include AssociationMacros
+      include TimeDimensions
+      include PredicateBuilder::Handlers
+
+      delegate :resolve_time_coords, to: :class
+
+      default_scope do
+        at_time(Querying::ScopeRegistry.global_constraints_for(time_dimensions))
+      end
+
+      scope :as_of, ->(time) do
+        time_coords = resolve_time_coords(time)
+
+        at_time(time_coords).time_tags(time_coords)
+      end
+
+      scope :at_time, ->(time) do
+        time_coords = resolve_time_coords(time)
+
+        constraints = time_coords.slice(*time_dimension_columns)
+
+        return if constraints.empty?
+
+        rewhere_contains(constraints.transform_values { |v| contains(v) })
+      end
+    end
+
+    def time_tags
+      @time_tags || {}
+    end
+
+    def time_tags=(value)
+      @time_tags = value&.slice(*time_dimensions)
+    end
+
+    def time_tag
+      time_tags[default_time_dimension]
+    end
+
+    def time_tags_for(time_dimensions)
+      time_tags.slice(*time_dimensions)
+    end
+
+    def as_of!(time)
+      time_coords = resolve_time_coords(time)
+
+      ensure_time_tags_in_bounds!(time_coords)
+
+      reload
+
+      self.time_tags = time_coords
+    end
+
+    def as_of(time)
+      time_coords = resolve_time_coords(time)
+
+      self.class.as_of(time_coords).find_by(self.class.primary_key => [id])
+    end
+
+    def initialize_time_tags_from_relation(relation)
+      associations = relation.includes_values | relation.eager_load_values
+
+      self.time_tags = relation.time_tag_values
+
+      AssociationWalker.each_target(self, associations) do |target|
+        target.time_tags = relation.time_tag_values
+      end
+    end
+
+    private
+
+    def ensure_time_tags_in_bounds!(time_tags)
+      time_tags.each do |dimension, time|
+        if time_dimension_column?(dimension) && !time_dimension(dimension).cover?(time)
+          raise RangeError, "#{time} is outside of '#{dimension}' range"
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/scoping.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::Temporal
+  module Scoping
+    def temporal_scoping
+      Querying::Scoping
+    end
+  end
+end

data/lib/activerecord/temporal/system_versioning/command_recorder.rb

@@ -1,10 +1,26 @@
 module ActiveRecord::Temporal
   module SystemVersioning
     module CommandRecorder
+      module ArrayExtractOptions
+        refine Array do
+          def extract_options
+            if last.is_a?(Hash) && last.extractable_options?
+              last
+            else
+              {}
+            end
+          end
+        end
+      end
+
+      using ArrayExtractOptions
+
       [
         :create_versioning_hook,
         :drop_versioning_hook,
-        :change_versioning_hook
+        :change_versioning_hook,
+        :create_table_with_system_versioning,
+        :drop_table_with_system_versioning
       ].each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{method}(*args)
@@ -42,6 +58,16 @@ module ActiveRecord::Temporal
           ]
         ]
       end
+
+      def invert_create_table_with_system_versioning(args)
+        [:drop_table_with_system_versioning, args]
+      end
+
+      def invert_drop_table_with_system_versioning(args)
+        # TODO make this reversible
+
+        raise ActiveRecord::IrreversibleMigration, "drop_table_with_system_versioning is not reversible"
+      end
     end
   end
 end

data/lib/activerecord/temporal/system_versioning/history_model.rb

@@ -0,0 +1,47 @@
+module ActiveRecord::Temporal
+  module SystemVersioning
+    module HistoryModel
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def polymorphic_class_for(name)
+          super.version_model
+        end
+
+        def sti_name
+          superclass.sti_name
+        end
+
+        def find_sti_class(type_name)
+          superclass.send(:find_sti_class, type_name).history_model
+        end
+
+        def finder_needs_type_condition?
+          superclass.finder_needs_type_condition?
+        end
+      end
+
+      included do
+        include Querying
+
+        if include?(SystemVersioned)
+          self.table_name = history_table_name
+          self.primary_key = Array(primary_key) + [:system_period]
+        end
+
+        self.time_dimensions = time_dimensions + [:system_period]
+
+        reflect_on_all_associations.each do |reflection|
+          next if reflection.scope&.temporal_scope?
+
+          send(
+            reflection.macro,
+            reflection.name,
+            reflection.scope,
+            **reflection.options.merge(temporal: true)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/system_versioning/history_model_namespace.rb

@@ -0,0 +1,45 @@
+module ActiveRecord::Temporal
+  module SystemVersioning
+    module HistoryModelNamespace
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def const_missing(model_name)
+          model = join(@root, model_name).constantize
+        rescue NameError
+          super
+        else
+          unless model.is_a?(Class) && model < ActiveRecord::Base
+            raise NameError, "#{model} is not a descendent of ActiveRecord::Base"
+          end
+
+          history_model = Class.new(model) do
+            include HistoryModel
+          end
+
+          const_set(model_name, history_model)
+        end
+
+        def namespace(name, &block)
+          new_namespace = Module.new do
+            include HistoryModelNamespace
+          end
+
+          const_set(name, new_namespace)
+
+          new_namespace.root(join(@root, name))
+
+          new_namespace.instance_eval(&block) if block
+        end
+
+        def root(name)
+          @root = name
+        end
+
+        def join(base, name)
+          [base, name].compact.join("::")
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/system_versioning/history_models.rb

@@ -0,0 +1,29 @@
+module ActiveRecord::Temporal
+  module SystemVersioning
+    module HistoryModels
+      class Error < StandardError; end
+
+      extend ActiveSupport::Concern
+
+      class_methods do
+        delegate :at_time, :as_of, to: :history
+
+        def history_model
+          raise Error, "abstract classes cannot have a history model" if abstract_class?
+
+          [history_model_namespace, name].join("::").constantize
+        end
+
+        def history
+          ActiveRecord::Relation.create(history_model)
+        end
+
+        private
+
+        def history_model_namespace
+          History
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/system_versioning/migration.rb

@@ -0,0 +1,35 @@
+module ActiveRecord::Temporal
+  module SystemVersioning
+    module Migration
+      extend ActiveSupport::Concern
+
+      included do
+        prepend Patches
+      end
+
+      module Patches
+        def create_table(table_name, id: :primary_key, primary_key: nil, force: nil, **options, &block)
+          system_versioning = options.delete(:system_versioning)
+
+          if system_versioning
+            create_table_with_system_versioning(
+              table_name, id:, primary_key:, force:, **options, &block
+            )
+          else
+            super
+          end
+        end
+
+        def drop_table(*table_names, **options)
+          system_versioning = options.delete(:system_versioning)
+
+          if system_versioning
+            drop_table_with_system_versioning(*table_names, **options)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/system_versioning/schema_creation.rb

@@ -52,7 +52,7 @@ module ActiveRecord::Temporal
 
       def visit_UpdateHookDefinition(o)
         column_names = o.columns.map { |c| quote_column_name(c) }
-        primary_key_quoted = o.primary_key.map { |c| quote_column_name(c) }
+        primary_key_quoted = Array(o.primary_key).map { |c| quote_column_name(c) }
         fields = column_names.join(", ")
         values = column_names.map { |c| "NEW.#{c}" }.join(", ")
         update_pk_predicates = primary_key_quoted.map { |c| "#{c} = OLD.#{c}" }.join(" AND ")
@@ -94,7 +94,7 @@ module ActiveRecord::Temporal
       end
 
       def visit_DeleteHookDefinition(o)
-        primary_key_quoted = o.primary_key.map { |c| quote_column_name(c) }
+        primary_key_quoted = Array(o.primary_key).map { |c| quote_column_name(c) }
         function_name = versioning_function_name(o.source_table, :delete)
         pk_predicates = primary_key_quoted.map { |c| "#{c} = OLD.#{c}" }.join(" AND ")
         metadata = {

data/lib/activerecord/temporal/system_versioning/schema_statements.rb

@@ -1,32 +1,96 @@
 module ActiveRecord::Temporal
   module SystemVersioning
     module SchemaStatements
+      def create_table_with_system_versioning(table_name, **options, &block)
+        create_table(table_name, **options, &block)
+
+        source_pk = Array(primary_key(table_name))
+        history_options = options.merge(primary_key: source_pk + ["system_period"])
+
+        exclusion_constraint_expression = source_pk.map do |col|
+          "#{col} WITH ="
+        end.join(", ") + ", system_period WITH &&"
+
+        create_table("#{table_name}_history", **history_options) do |t|
+          columns(table_name).each do |column|
+            t.send(
+              column.type,
+              column.name,
+              comment: column.comment,
+              collation: column.collation,
+              default: nil,
+              limit: column.limit,
+              null: column.null,
+              precision: column.precision,
+              scale: column.scale
+            )
+          end
+
+          t.tstzrange :system_period, null: false
+          t.exclusion_constraint exclusion_constraint_expression, using: :gist
+        end
+
+        create_versioning_hook table_name,
+          "#{table_name}_history",
+          columns: :all,
+          primary_key: source_pk
+      end
+
+      def drop_table_with_system_versioning(*table_names, **options)
+        table_names.each do |table_name|
+          history_table_name = "#{table_name}_history"
+
+          drop_table(table_name, **options)
+          drop_table(history_table_name, **options)
+          drop_versioning_hook(table_name, history_table_name, **options.slice(:columns, :primary_key, :if_exists))
+        end
+      end
+
       def create_versioning_hook(source_table, history_table, **options)
-        columns = options.fetch(:columns)&.map(&:to_s)
-        primary_key = Array(options.fetch(:primary_key, :id))
+        options.assert_valid_keys(:columns, :primary_key)
+
+        column_names = if (columns = options.fetch(:columns)) == :all
+          columns(source_table).map(&:name)
+        else
+          Array(columns).map(&:to_s)
+        end
+
+        primary_key = options.fetch(:primary_key, :id)
+
+        primary_key = if primary_key.is_a?(Array) && primary_key.length == 1
+          primary_key.first
+        else
+          primary_key
+        end
 
         ensure_table_exists!(source_table)
         ensure_table_exists!(history_table)
-        ensure_columns_match!(source_table, history_table, columns)
-        ensure_columns_exists!(source_table, primary_key)
+        ensure_columns_match!(source_table, history_table, column_names)
+        ensure_columns_exists!(source_table, Array(primary_key))
 
         schema_creation = SchemaCreation.new(self)
 
         hook_definition = VersioningHookDefinition.new(
           source_table,
           history_table,
-          columns: columns,
+          columns: column_names,
           primary_key: primary_key
         )
 
         execute schema_creation.accept(hook_definition)
       end
 
-      def drop_versioning_hook(source_table, history_table, columns: nil)
+      def drop_versioning_hook(source_table, history_table, **options)
+        options.assert_valid_keys(:columns, :primary_key, :if_exists)
+
         %i[insert update delete].each do |verb|
           function_name = versioning_function_name(source_table, verb)
 
-          execute "DROP FUNCTION #{function_name}() CASCADE"
+          sql = "DROP FUNCTION"
+          sql << " IF EXISTS" if options[:if_exists]
+          sql << " #{function_name}() CASCADE"
+
+          execute sql
         end
       end
 
@@ -56,6 +120,8 @@ module ActiveRecord::Temporal
       end
 
       def change_versioning_hook(source_table, history_table, options)
+        options.assert_valid_keys(:add_columns, :remove_columns)
+
         add_columns = (options[:add_columns] || []).map(&:to_s)
         remove_columns = (options[:remove_columns] || []).map(&:to_s)
 
@@ -71,7 +137,10 @@ module ActiveRecord::Temporal
 
         new_columns = hook_definition.columns + add_columns - remove_columns
 
-        create_versioning_hook(source_table, history_table, columns: new_columns)
+        create_versioning_hook source_table,
+          history_table,
+          columns: new_columns,
+          primary_key: hook_definition.primary_key
       end
 
       def history_table(source_table)
@@ -89,6 +158,9 @@ module ActiveRecord::Temporal
 
       private
 
+      def validate_create_versioning_hook_options!(options)
+      end
+
       def ensure_table_exists!(table_name)
         return if table_exists?(table_name)
 

data/lib/activerecord/temporal/system_versioning/system_versioned.rb

@@ -0,0 +1,13 @@
+module ActiveRecord::Temporal
+  module SystemVersioning
+    module SystemVersioned
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def history_table_name
+          table_name + "_history" if table_name
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/temporal/system_versioning.rb

@@ -2,25 +2,13 @@ module ActiveRecord::Temporal
   module SystemVersioning
     extend ActiveSupport::Concern
 
-    class_methods do
-      def history_table
-        connection.history_table(table_name)
-      end
-
-      def primary_key_from_db
-        Array(connection.primary_key(table_name)).map(&:to_sym)
-      end
-
-      def version_model
-        "Version::#{name}".constantize
-      end
+    included do
+      include HistoryModels
+    end
 
-      def system_versioning(namespace: "Version")
-        unless Object.const_defined?(namespace)
-          mod = Module.new
-          mod.include(Namespace)
-          Object.const_set(namespace, mod)
-        end
+    class_methods do
+      def system_versioned
+        include SystemVersioned
       end
     end
   end

data/lib/activerecord/temporal/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecord::Temporal
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end