temporal_tables 0.6.1

data/gemfiles/Gemfile.5.2.pg

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Runtime dependencies
+gem 'rails', '~> 5.2.0'
+gem 'pg', '>= 0.18', '< 2.0'
+
+# Development dependencies
+gem 'rspec', '~> 3.4'
+gem 'rake'
+gem 'byebug'
+gem 'database_cleaner'
+gem 'combustion'
+gem 'gemika'
+
+# Gem under test
+gem 'temporal_tables', :path => '..'

data/gemfiles/Gemfile.5.2.pg.lock

@@ -0,0 +1,155 @@
+PATH
+  remote: ..
+  specs:
+    temporal_tables (0.6.0)
+      rails (~> 5.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (5.2.0)
+      actionpack (= 5.2.0)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailer (5.2.0)
+      actionpack (= 5.2.0)
+      actionview (= 5.2.0)
+      activejob (= 5.2.0)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (5.2.0)
+      actionview (= 5.2.0)
+      activesupport (= 5.2.0)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.0)
+      activesupport (= 5.2.0)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activejob (5.2.0)
+      activesupport (= 5.2.0)
+      globalid (>= 0.3.6)
+    activemodel (5.2.0)
+      activesupport (= 5.2.0)
+    activerecord (5.2.0)
+      activemodel (= 5.2.0)
+      activesupport (= 5.2.0)
+      arel (>= 9.0)
+    activestorage (5.2.0)
+      actionpack (= 5.2.0)
+      activerecord (= 5.2.0)
+      marcel (~> 0.3.1)
+    activesupport (5.2.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    builder (3.2.3)
+    byebug (10.0.2)
+    combustion (0.9.1)
+      activesupport (>= 3.0.0)
+      railties (>= 3.0.0)
+      thor (>= 0.14.6)
+    concurrent-ruby (1.0.5)
+    crass (1.0.4)
+    database_cleaner (1.7.0)
+    diff-lcs (1.3)
+    erubi (1.7.1)
+    gemika (0.3.2)
+    globalid (0.4.1)
+      activesupport (>= 4.2.0)
+    i18n (1.0.1)
+      concurrent-ruby (~> 1.0)
+    loofah (2.2.2)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.0)
+      mini_mime (>= 0.1.1)
+    marcel (0.3.2)
+      mimemagic (~> 0.3.2)
+    method_source (0.9.0)
+    mimemagic (0.3.2)
+    mini_mime (1.0.0)
+    mini_portile2 (2.3.0)
+    minitest (5.11.3)
+    nio4r (2.3.1)
+    nokogiri (1.8.4)
+      mini_portile2 (~> 2.3.0)
+    pg (1.0.0)
+    rack (2.0.5)
+    rack-test (1.0.0)
+      rack (>= 1.0, < 3)
+    rails (5.2.0)
+      actioncable (= 5.2.0)
+      actionmailer (= 5.2.0)
+      actionpack (= 5.2.0)
+      actionview (= 5.2.0)
+      activejob (= 5.2.0)
+      activemodel (= 5.2.0)
+      activerecord (= 5.2.0)
+      activestorage (= 5.2.0)
+      activesupport (= 5.2.0)
+      bundler (>= 1.3.0)
+      railties (= 5.2.0)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (5.2.0)
+      actionpack (= 5.2.0)
+      activesupport (= 5.2.0)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (12.3.1)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    sprockets (3.7.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.1)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    websocket-driver (0.7.0)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  combustion
+  database_cleaner
+  gemika
+  pg (>= 0.18, < 2.0)
+  rails (~> 5.2.0)
+  rake
+  rspec (~> 3.4)
+  temporal_tables!
+
+BUNDLED WITH
+   1.16.1

data/lib/temporal_tables.rb

@@ -0,0 +1,63 @@
+require "temporal_tables/temporal_adapter"
+require "temporal_tables/connection_adapters/mysql_adapter"
+require "temporal_tables/connection_adapters/postgresql_adapter"
+require "temporal_tables/whodunnit"
+require "temporal_tables/temporal_class"
+require "temporal_tables/history_hook"
+require "temporal_tables/relation_extensions"
+require "temporal_tables/scope_extensions"
+require "temporal_tables/version"
+
+module TemporalTables
+	class Railtie < ::Rails::Railtie
+		initializer "temporal_tables.load" do
+			# Iterating the subclasses will find any adapter implementations
+			# which are in use by the rails app, and mixin the temporal functionality.
+			# It's necessary to do this on the implementations in order for the
+			# alias method chain hooks to work.
+			ActiveRecord::ConnectionAdapters::AbstractAdapter.subclasses.each do |subclass|
+				subclass.send :prepend, TemporalTables::TemporalAdapter
+
+				module_name = subclass.name.split("::").last
+				subclass.send :prepend, TemporalTables::ConnectionAdapters.const_get(module_name) if TemporalTables::ConnectionAdapters.const_defined?(module_name)
+			end
+
+			ActiveRecord::Base.send :prepend, TemporalTables::Whodunnit
+		end
+	end
+
+	@@create_by_default = false
+	def self.create_by_default
+		@@create_by_default
+	end
+	def self.create_by_default=(default)
+		@@create_by_default = default
+	end
+
+	@@skipped_temporal_tables = [:schema_migrations, :sessions]
+	def self.skip_temporal_table_for(*tables)
+		@@skipped_temporal_tables += tables
+	end
+	def self.skipped_temporal_tables
+		@@skipped_temporal_tables.dup
+	end
+
+	@@add_updated_by_field = false
+	@@updated_by_type = :string
+	@@updated_by_proc = nil
+	def self.updated_by_type
+		@@updated_by_type
+	end
+	def self.updated_by_proc
+		@@updated_by_proc
+	end
+	def self.add_updated_by_field(type = :string, &block)
+		if block_given?
+			@@add_updated_by_field = true
+			@@updated_by_type = type
+			@@updated_by_proc = block
+		end
+
+		@@add_updated_by_field
+	end
+end

data/lib/temporal_tables/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,56 @@
+module TemporalTables
+	module ConnectionAdapters
+		module AbstractMysqlAdapter
+			def drop_temporal_triggers(table_name)
+				execute "drop trigger #{table_name}_ai"
+				execute "drop trigger #{table_name}_au"
+				execute "drop trigger #{table_name}_ad"
+			end
+
+			def create_temporal_triggers(table_name)
+				column_names = columns(table_name).map(&:name)
+
+				execute %{
+					create trigger #{table_name}_ai after insert on #{table_name}
+					for each row
+					begin
+						set @current_time = utc_timestamp(6);
+
+						insert into #{temporal_name(table_name)} (#{column_names.join(', ')}, eff_from)
+						values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, @current_time);
+
+					end
+				}
+
+				execute %{
+					create trigger #{table_name}_au after update on #{table_name}
+					for each row
+					begin
+						set @current_time = utc_timestamp(6);
+
+						update #{temporal_name(table_name)} set eff_to = @current_time
+						where id = new.id
+						and eff_to = '9999-12-31';
+
+						insert into #{temporal_name(table_name)} (#{column_names.join(', ')}, eff_from)
+						values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, @current_time);
+
+					end
+				}
+
+				execute %{
+					create trigger #{table_name}_ad after delete on #{table_name}
+					for each row
+					begin
+						set @current_time = utc_timestamp(6);
+
+						update #{temporal_name(table_name)} set eff_to = @current_time
+						where id = old.id
+						and eff_to = '9999-12-31';
+
+					end
+				}
+			end
+		end
+	end
+end

data/lib/temporal_tables/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,81 @@
+module TemporalTables
+	module ConnectionAdapters
+		module PostgreSQLAdapter
+			def drop_temporal_triggers(table_name)
+				execute "drop trigger #{table_name}_ai on #{table_name}"
+				execute "drop trigger #{table_name}_au on #{table_name}"
+				execute "drop trigger #{table_name}_ad on #{table_name}"
+			end
+
+			def create_temporal_triggers(table_name)
+				column_names = columns(table_name).map(&:name)
+
+				execute %{
+					create or replace function #{table_name}_ai() returns trigger as $#{table_name}_ai$
+						declare
+							cur_time timestamp without time zone;
+						begin
+							cur_time := localtimestamp;
+
+							insert into #{temporal_name(table_name)} (#{column_list(column_names)}, eff_from)
+							values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, cur_time);
+
+							return null;
+						end
+					$#{table_name}_ai$ language plpgsql;
+
+					drop trigger if exists #{table_name}_ai on #{table_name};
+					create trigger #{table_name}_ai after insert on #{table_name}
+					for each row execute procedure #{table_name}_ai();
+				}
+
+				execute %{
+					create or replace function #{table_name}_au() returns trigger as $#{table_name}_au$
+						declare
+							cur_time timestamp without time zone;
+						begin
+							cur_time := localtimestamp;
+
+							update #{temporal_name(table_name)} set eff_to = cur_time
+							where id = new.id
+								and eff_to = '9999-12-31';
+
+							insert into #{temporal_name(table_name)} (#{column_list(column_names)}, eff_from)
+							values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, cur_time);
+
+							return null;
+						end
+					$#{table_name}_au$ language plpgsql;
+
+					drop trigger if exists #{table_name}_au on #{table_name};
+					create trigger #{table_name}_au after update on #{table_name}
+					for each row execute procedure #{table_name}_au();
+				}
+
+				execute %{
+					create or replace function #{table_name}_ad() returns trigger as $#{table_name}_ad$
+						declare
+							cur_time timestamp without time zone;
+						begin
+							cur_time := localtimestamp;
+
+							update #{temporal_name(table_name)} set eff_to = cur_time
+							where id = old.id
+								and eff_to = '9999-12-31';
+
+							return null;
+						end
+					$#{table_name}_ad$ language plpgsql;
+
+					drop trigger if exists #{table_name}_ad on #{table_name};
+					create trigger #{table_name}_ad after delete on #{table_name}
+					for each row execute procedure #{table_name}_ad();
+				}
+			end
+
+			def column_list(column_names)
+				column_names.map { |c| "\"#{c}\"" }.join(', ')
+			end
+		end
+	end
+end

data/lib/temporal_tables/history_hook.rb

@@ -0,0 +1,50 @@
+module TemporalTables
+	# This hooks in a "history" method to ActiveRecord::Base which will
+	# return the class's History class.  The history class extends the original
+	# class, but runs against the history table to provide temporal results.
+	#
+	#  class Person < ActiveRecord::Base
+	#    attr_accessible :name
+	#  end
+	#
+	#  Person         #=> Person(id: integer, name: string)
+	#  Person.history #=> PersonHistory(history_id: integer, id: integer, name: string, eff_from: datetime, eff_to: datetime)
+	module HistoryHook
+		def self.included(base)
+			base.class_eval do
+				# Return this class's history class.
+				# If it doesn't exist yet, create and initialize it, as well
+				# as all dependent classes (through associations).
+				def self.history
+					raise "Can't view history of history" if name =~ /History$/
+
+					history_class = "#{name}History"
+					history_class.constantize
+				rescue NameError
+					# If the history class doesn't exist yet, create it
+					new_class = Class.new(self) do
+						include TemporalTables::TemporalClass
+					end
+					segments = history_class.split("::")
+					object_class = segments[0...-1].inject(Object) { |o, s| o.const_get(s) }
+					object_class.const_set segments.last, new_class
+
+					# Traverse associations and make sure they have
+					# history classes too.
+					history_class.constantize.temporalize_associations!
+					history_class.constantize
+				end	
+			end
+		end
+
+		# Returns a scope for the list of all history records for this 
+		# particular object.
+		def history
+			clazz = is_a?(TemporalTables::TemporalClass) ? self.class : self.class.history
+			oid = is_a?(TemporalTables::TemporalClass) ? orig_class.primary_key : self.class.primary_key
+			clazz.unscoped.where(id: attributes[oid]).order(:eff_from)
+		end
+	end
+end
+
+ActiveRecord::Base.send :include, TemporalTables::HistoryHook

data/lib/temporal_tables/relation_extensions.rb

@@ -0,0 +1,125 @@
+module TemporalTables
+	# Stores the time from the "at" field into each of the resulting objects
+	# so that it can be carried forward in subsequent queries.
+	module RelationExtensions
+		def self.included(base)
+			base.class_eval do
+				ActiveRecord::Relation::SINGLE_VALUE_METHODS << :at
+			end
+		end
+
+    def at_value
+      get_value(:at) || Thread.current[:at_time]
+    end
+
+    def at_value=(value)
+      set_value(:at, value)
+    end
+
+		def at(*args)
+      spawn.at!(*args)
+		end
+
+		def at!(value)
+			self.at_value = value
+			self
+		end
+
+		def where_clause
+			s = super
+
+			at_clauses = []
+			if historical?
+				at_clauses << where_clause_factory.build(
+					arel_table[:eff_to].gteq(at_value).and(
+						arel_table[:eff_from].lteq(at_value)
+					),
+					[]
+				)
+			end
+
+			[s, *at_clauses.compact].sum
+		end
+
+		def to_sql(*args)
+			threadify_at do
+				super *args
+			end
+		end
+
+		def threadify_at
+			if at_value && !Thread.current[:at_time]
+				Thread.current[:at_time] = at_value
+				result = yield
+				Thread.current[:at_time] = nil
+			else
+				result = yield
+			end
+			result
+		end
+
+		def limited_ids_for(*args)
+			threadify_at do
+				super *args
+			end
+		end
+
+		def exec_queries
+			# Note that record preloading, like when you specify
+			#  MyClass.includes(:associations)
+			# happens within this exec_queries call.  That's why we needed to
+			# store the at_time in the thread above.
+			threadify_at do
+				super
+			end
+
+			if historical?
+				# Store the at value on each record returned
+				# TODO: traverse preloaded associations too
+				@records.each do |r|
+					r.at_value = at_value
+				end
+			end
+			@records
+		end
+
+		def historical?
+			table_name =~ /_h$/i && at_value
+		end
+	end
+
+	# Uses the time from the "at" field stored in the record to filter queries
+	# made to associations.
+	module AssociationExtensions
+		def target_scope
+			if @owner.respond_to?(:at_value)
+				# If this is a history record but no at time was given,
+				# assume the record's effective to date
+				super.at(@owner.at_value || @owner.eff_to)
+			else
+				super
+			end
+		end
+	end
+
+	# Uses the at time when fetching preloaded records
+	module PreloaderExtensions
+		def build_scope
+			# It seems the at time can be in either of these places, but not both,
+			# depending on when the preloading happens to be done
+			at_time = @owners.first.at_value if @owners.first.respond_to?(:at_value)
+			at_time ||= Thread.current[:at_time]
+
+			if at_time
+				super.at(at_time)
+			else
+				super
+			end
+		end
+	end
+
+end
+
+ActiveRecord::Relation.send :prepend, TemporalTables::RelationExtensions
+ActiveRecord::Associations::Association.send :prepend, TemporalTables::AssociationExtensions
+ActiveRecord::Associations::Preloader::Association.send :prepend, TemporalTables::PreloaderExtensions