snaptime 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 105979aad445d0e6f274857977310cd72e6b43c0
+  data.tar.gz: 8230ef5d4b9f5454000d5f9297ea9243fc3e0b09
+SHA512:
+  metadata.gz: 6c8f2cd32556bc1cabf50bdde6b47fc26112864e01e6f12a0a6d0d86e3e8cb73c5597c4be5ad92c21957ce19267df89e57c0d8f856757012a5cc7d353a1732dd
+  data.tar.gz: 15ebe2cee56f8c14281124e00a2bb0c712083f9fa46e1c44bf48909e3661e2c7c92f55d8422f0ca20c0985c6f174b48b847e27a7b02f009f71f75b03087e1a27

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.releaser_config

@@ -0,0 +1,3 @@
+version_file: VERSION
+always_from_master: true
+gem_style: github

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify gem dependencies in the .gemspec file
+gemspec

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    snaptime (0.0.1)
+      activerecord
+      activesupport
+      request_store
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activerecord (5.2.3)
+      activemodel (= 5.2.3)
+      activesupport (= 5.2.3)
+      arel (>= 9.0)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    ast (2.4.0)
+    benchmark-ips (2.7.2)
+    concurrent-ruby (1.1.5)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    mysql2 (0.5.2)
+    parallel (1.17.0)
+    parser (2.6.2.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    rack (2.0.7)
+    rainbow (2.2.2)
+      rake
+    rake (12.3.2)
+    request_store (1.4.1)
+      rack (>= 1.4)
+    rubocop (0.51.0)
+      parallel (~> 1.10)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.10.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  benchmark-ips
+  bundler (~> 2.0)
+  minitest
+  mysql2
+  rake
+  rubocop (= 0.51.0)
+  snaptime!
+
+BUNDLED WITH
+   2.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Sitrox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# snaptime
+
+**This Gem is still in an early stage of development. Please not use this in production yet.**
+
+Snaptime lets you versionize Active Record models using single table versioning.
+Records are identified by a `natural_id` and their validity is controlled via
+`valid_from` and `valid_to`. Snaptime also supports associations between
+versioned models as well as associations to and from unversioned models.
+
+## Reasons for snaptime
+
+* Most of Snaptime's operation is transparent, so you won't even notice that
+  a certain model is versioned if you don't explicitely want to.
+
+* Associations between, to and from versioned models are automatically handeled.
+  This lets Snaptime version entire, complex hierarchies.
+
+* It is very lightweight.
+
+* It is non-intrusive. It does not overwrite a single Rails method without
+  you explicitly telling it to do so.
+
+* It can be easily extended to support other database adapters.
+
+## Basic concept
+
+Snaptime can be enabled on a per-model basis. Using dedicated migration methods,
+each versioned table is complemented with the following fields:
+
+- `natural_id`
+
+  This is the ID that does not change between versions. This is also the ID
+  that is referenced when pointing to a versioned model.
+
+- `valid_from`, `valid_to`
+
+  These are UTC timestamps in milliseconds that specify a specific version's
+  validity. The field `valid_from` always specifies the point in time at which
+  a certain version has been created, while `valid_to` says when the version
+  got outdated. This can happen by deleting the record (which does not actually
+  delete it but just sets `valid_to`) or when a new version arises. There can't
+  be any gaps between the validity fields of a version string.
+
+Snaptime works by hooking into your versioned models at *creation*, *update* and
+*deletion*:
+
+- At creation, it automatically generates a new `natural_id` and sets
+  `valid_from` to the current time.
+
+- At update, `valid_from` is again set to the current time and the record is
+  updated as usual. But before the record gets updated, Snaptime creates a copy
+  of the record's current state and sets `valid_from` and `valid_to`
+  accordingly. The copy is created in-db (using `insert ... select`) and does
+  not call any application side logic.
+
+- At deletion, all it does is setting `valid_to` of the current record to the
+  current time again.
+
+What this means is that the original record always stays the newest one. This
+has many advantages, as the record itself can be updated as usual and if another
+model would ever point at the `id` instead the `natural_id`, it would always
+point to the newest one.
+
+## Basic setup
+
+### Gemfile
+
+Add the following to your application's Gemfile:
+
+```ruby
+gem :snaptime
+```
+
+You can also specify a fixed version:
+
+```ruby
+gem :snaptime, '~> 1.0.0'
+```
+
+### Setup task
+
+Snaptime needs to generate a `natural_id` next to your `id`. In some adapters,
+this can be done using database sequences, while other databases require a
+custom setup (i.e. MySQL let's you workaround this by adding a dedicated
+sequence table as well as a custom procedure).
+
+Using the following rake task, Snaptime automatically generates the required
+migrations. Note that this migration only performs a basic setup and does not
+enable any of your models to be versioned. This happens using separate
+migrations as described in the following chapters.
+
+```bash
+rake snaptime:setup -- <adapter-name>
+```
+
+Replace `<adapter-name>` with the name of your database adapter. Spell it
+exactly as the `adapter` setting of your database configuration reads. If the
+specific adapter does not require any setup, you will get a respective message.
+
+## Versionizing a model
+
+### Performing the database migrations
+
+TODO
+
+### Include the versionize module
+
+```ruby
+class YourModel < ActiveRecord::Base
+  include Snaptime::Versioned
+end
+```
+
+## Caveats
+
+- Do not use `def self.default_scope` but `default_scope do` in versioned models
+  if you need to extend the default scope.
+- `.unscoped` also removes the default scope added by snaptime.

data/Rakefile

@@ -0,0 +1,34 @@
+task :gemspec do
+  gemspec = Gem::Specification.new do |spec|
+    spec.name          = 'snaptime'
+    spec.version       = IO.read('VERSION').chomp
+    spec.authors       = ['Sitrox']
+    spec.summary       = %(
+      Multi-threaded job backend with database queuing for ruby.
+    )
+    spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+    spec.executables   = []
+    spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+    spec.require_paths = ['lib']
+
+    spec.add_development_dependency 'bundler', '~> 2.0'
+    spec.add_development_dependency 'rake'
+    spec.add_development_dependency 'rubocop', '0.51.0'
+    spec.add_development_dependency 'minitest'
+    spec.add_development_dependency 'mysql2'
+    spec.add_development_dependency 'benchmark-ips'
+    spec.add_dependency 'activesupport'
+    spec.add_dependency 'activerecord'
+    spec.add_dependency 'request_store'
+  end
+
+  File.open('snaptime.gemspec', 'w') { |f| f.write(gemspec.to_ruby.strip) }
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/snaptime/**/*_test.rb'
+  t.verbose = false
+  t.libs << 'test/lib'
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/snaptime.rb

@@ -0,0 +1,121 @@
+require 'snaptime/migration_helpers'
+require 'snaptime/record_cloner'
+require 'snaptime/harvester'
+require 'snaptime/versioned/scopes'
+require 'snaptime/exceptions'
+require 'snaptime/relations_builder'
+require 'snaptime/railtie'
+require 'snaptime/ar_hooks'
+require 'snaptime/base_ar_mixin'
+require 'snaptime/relations'
+require 'snaptime/virtual_models/snaptime'
+require 'snaptime/versioned'
+
+module Snptime
+  SNAPTIME_REQUEST_STORE_KEY = :snaptime_snaptime
+  CURRENT_NOW_REQUEST_STORE_KEY = :snaptime_current_now
+  CLONED_RECORDS_STORE_KEY = :snaptime_cloned_records
+  RECORD_CLONING_SWITCH_REQUEST_STORE_KEY = :snaptime_record_cloning
+  SMALLEST_TIME_UNIT = 0.001
+
+  @consolidation_fields = ActiveSupport::OrderedHash.new
+
+  def self.register_consolidation_field(name, aggregate_with: nil, default: Arel.sql('null'))
+    @consolidation_fields[name] = { aggregate_with: aggregate_with, default: default }
+  end
+
+  def self.consolidation_fields
+    @consolidation_fields
+  end
+
+  @model_class = Snaptime::VirtualModels::Snaptime
+
+  def self.model_class=(model_class)
+    @model_class = model_class
+  end
+
+  def self.model_class
+    @model_class
+  end
+
+  def self.with_snaptime(snaptime, &_block)
+    previous_snaptime = RequestStore.store[SNAPTIME_REQUEST_STORE_KEY]
+
+    RequestStore.store[SNAPTIME_REQUEST_STORE_KEY] = snaptime
+
+    begin
+      yield
+    ensure
+      RequestStore.store[SNAPTIME_REQUEST_STORE_KEY] = previous_snaptime
+    end
+  end
+
+  def self.without_record_cloning(&_block)
+    previous_setting = RequestStore.store[RECORD_CLONING_SWITCH_REQUEST_STORE_KEY]
+
+    RequestStore.store[RECORD_CLONING_SWITCH_REQUEST_STORE_KEY] = false
+
+    begin
+      yield
+    ensure
+      RequestStore.store[RECORD_CLONING_SWITCH_REQUEST_STORE_KEY] = previous_setting
+    end
+  end
+
+  def self.record_cloning_enabled?
+    RequestStore.store[RECORD_CLONING_SWITCH_REQUEST_STORE_KEY] != false
+  end
+
+  def self.snaptime
+    RequestStore.store[SNAPTIME_REQUEST_STORE_KEY]
+  end
+
+  def self.current_now
+    RequestStore.store[CURRENT_NOW_REQUEST_STORE_KEY] ||= Time.now.utc
+  end
+
+  # Override the "current now" used for creating new versions. Only use this
+  # method for testing purposes and make sure you use `reset_current_now` if
+  # necessary. Use `with_fake_current_now` whenever possible.
+  def self.fake_current_now(time)
+    RequestStore.store[CURRENT_NOW_REQUEST_STORE_KEY] ||= time.utc
+  end
+
+  # Override the "current now" used for creating new versions. Only use this
+  # method for testing purposes.
+  def self.with_fake_current_now(time, &_block)
+    fake_current_now time
+
+    begin
+      yield
+    ensure
+      reset_current_now
+    end
+  end
+
+  def self.reset_current_now
+    RequestStore.store[CURRENT_NOW_REQUEST_STORE_KEY] = nil
+  end
+
+  def self.record_cloned_in_current_tx(record)
+    RequestStore.store[CLONED_RECORDS_STORE_KEY] ||= {}
+    RequestStore.store[CLONED_RECORDS_STORE_KEY][record.class.table_name] ||= {}
+    RequestStore.store[CLONED_RECORDS_STORE_KEY][record.class.table_name][record.send(record.class.primary_key)] = true
+  end
+
+  def self.record_cloned_in_current_tx?(record)
+    RequestStore.store
+                .try(:[], CLONED_RECORDS_STORE_KEY)
+                .try(:[], record.class.table_name)
+                .try(:[], record.send(record.class.primary_key)) || false
+  end
+
+  def self.reset_records_cloned_in_current_tx
+    RequestStore.store[CLONED_RECORDS_STORE_KEY] = nil
+  end
+
+  def self.after_commit_or_rollback
+    reset_current_now
+    reset_records_cloned_in_current_tx
+  end
+end

data/lib/snaptime/ar_hooks.rb

@@ -0,0 +1,38 @@
+module Snaptime
+  module ArHooks
+    def self.before_create(record)
+      if record.natural_id.nil?
+        record.valid_from = Snaptime.current_now
+        ActiveRecord::Base.uncached do
+          record.natural_id = record.class.connection.next_sequence_value(record.class.sequence_name)
+        end
+      end
+    end
+
+    def self.after_create(record)
+      Snaptime.record_cloned_in_current_tx(record)
+    end
+
+    def self.before_update(record)
+      return unless Snaptime.record_cloning_enabled?
+
+      if record.valid_to.nil? && record.changed? && !Snaptime.record_cloned_in_current_tx?(record)
+        record.valid_from = Snaptime.current_now
+
+        Snaptime::RecordCloner.clone_record!(
+          record,
+          override_attributes: { valid_to: record.valid_from - SMALLEST_TIME_UNIT },
+          return_record: false
+        )
+
+        Snaptime.record_cloned_in_current_tx(record)
+      end
+    end
+
+    def self.destroy(record)
+      record.deleted = true
+      record.version_is_minor = true if record.respond_to?(:version_is_minor=)
+      record.save!
+    end
+  end
+end

data/lib/snaptime/base_ar_mixin.rb

@@ -0,0 +1,15 @@
+module Snaptime
+  module BaseArMixin
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def versioned?
+        false
+      end
+    end
+
+    def natural_id_or_id
+      self.class.versioned? ? natural_id : id
+    end
+  end
+end

data/lib/snaptime/exceptions.rb

@@ -0,0 +1,15 @@
+module Snaptime
+  module Exceptions
+    class DeleteMethodsAreNotAvailable < StandardError
+      def initialize
+        super('Versionized records only support the `destroy` methods.')
+      end
+    end
+
+    class AssociationTargetNotVersioned < StandardError
+      def initialize(target_class)
+        super("Association target #{target_class.inspect} does not appear to be versioned.")
+      end
+    end
+  end
+end

data/lib/snaptime/harvester.rb

@@ -0,0 +1,195 @@
+module Snaptime
+  module Harvester
+    def self.harvest_for(record)
+      # ---------------------------------------------------------------
+      # Build individual selects for each combination of table,
+      # key fields and values.
+      # ---------------------------------------------------------------
+      selects = []
+
+      queries = snaptime_queries(record.class, [record.natural_id], nil)
+
+      queries.each do |klass, keys_and_values|
+        keys_and_values.each do |key, values|
+          selects << select_for(klass, key, values)
+        end
+      end
+
+      # ---------------------------------------------------------------
+      # Build master select that unions all of the above queries
+      # TODO: Probably add a separate option for coalesce to avoid
+      #   doubling the code for max and min.
+      # ---------------------------------------------------------------
+      rel = Snaptime.model_class
+      rel = rel.from(
+        "#{union_selects(*selects)} inner_snaptimes"
+      )
+
+      # TODO: Move to DB-specific adapter
+      rel = rel.select(Arel.sql("LISTAGG(record_lookups, ';') WITHIN GROUP(ORDER BY record_lookups)").as('record_lookups'))
+
+      Snaptime.consolidation_fields.each do |field, options|
+        if options[:aggregate_with].nil?
+          rel = rel.select(field)
+        elsif options[:aggregate_with] == :max
+          rel = rel.select(Arel.sql(field.to_s).maximum.as(field.to_s))
+        elsif options[:aggregate_with] == :max_coalesce_0
+          rel = rel.select(
+            Arel.sql(
+              Arel::Nodes::NamedFunction.new('coalesce', [Arel.sql(field.to_s), Arel.sql(0.to_s)]).to_sql
+            ).maximum.as(field.to_s)
+          )
+        elsif options[:aggregate_with] == :min
+          rel = rel.select(Arel.sql(field.to_s).minimum.as(field.to_s))
+        elsif options[:aggregate_with] == :min_coalesce_0
+          rel = rel.select(
+            Arel.sql(
+              Arel::Nodes::NamedFunction.new('coalesce', [Arel.sql(field.to_s), Arel.sql(0.to_s)]).to_sql
+            ).minimum.as(field.to_s)
+          )
+        elsif options[:aggregate_with] == :sum
+          rel = rel.select(Arel.sql(field.to_s).sum.as(field.to_s))
+        end
+      end
+
+      grouping_fields = Snaptime.consolidation_fields.select { |_k, v| v[:aggregate_with].nil? }.keys.collect(&:to_s)
+      # rel = rel.order('inner_snaptimes.valid_from desc')
+      rel = rel.order(Arel::Table.new(:inner_snaptimes)[:valid_from].desc)
+      rel = rel.group(*grouping_fields)
+
+      # ---------------------------------------------------------------
+      # Wrap master select in another select so that outer orders,
+      # wheres and counts work out-of-the-box.
+      # ---------------------------------------------------------------
+      all_keys = [:record_lookups] + Snaptime.consolidation_fields.keys
+
+      all_fields = all_keys.collect do |key|
+        Arel::Table.new(:snaptimes)[key]
+      end
+
+      outer_rel = Snaptime.model_class.select(all_fields).from("(#{rel.to_sql}) snaptimes")
+
+      return outer_rel
+    end
+
+    def self.select_for(klass, key, values)
+      table = klass.arel_table
+
+      select = Arel::SelectManager.new(ActiveRecord::Base)
+      select.from table
+
+      concat = Arel::Nodes::NamedFunction.new('concat', [
+        Arel.sql(klass.connection.quote("#{klass.name},")),
+        table[klass.primary_key]
+      ])
+      select.project(
+        concat.as('record_lookups')
+      )
+
+      Snaptime.consolidation_fields.each do |field_key, options|
+        if klass.column_names.include?(field_key.to_s)
+          select.project(table[field_key.to_s])
+        else
+          unless options[:default].is_a?(Arel::Nodes::SqlLiteral)
+            fail 'Option :default must be an Arel::Nodes::SqlLiteral.'
+          end
+          select.project(options[:default].as(field_key.to_s))
+        end
+      end
+
+      select.where(table[key].in(values))
+
+      return select
+    end
+
+    private_class_method :select_for
+
+    def self.snaptime_queries(klass, natural_ids, association, visited_natural_ids_by_assoc = {})
+      queries = {}
+
+      # ---------------------------------------------------------------
+      # Abort if all natural IDs have already been processed for the
+      # given association.
+      # ---------------------------------------------------------------
+      visited_natural_ids_by_assoc[association] ||= []
+      return {} if (natural_ids - visited_natural_ids_by_assoc[association]).empty?
+      visited_natural_ids_by_assoc[association] += natural_ids
+
+      my_natural_ids = natural_ids
+
+      if association.nil? || association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        # Either:
+        #  I'm the root of the query, return all valid_from from my versions,
+        #  which are identified by my natural_id.
+        #
+        # Or:
+        #  I'm target of a belongs_to, I'm getting all natural_ids that my
+        #  peer is pointing to with his foreign key. So I will return all
+        #  valid_from that belong to these natural_ids.
+        queries[klass] ||= {}
+        queries[klass][:natural_id] ||= []
+        queries[klass][:natural_id] += natural_ids
+      elsif association.is_a?(ActiveRecord::Reflection::HasOneReflection) || association.is_a?(ActiveRecord::Reflection::HasManyReflection)
+        # I'm target of a has_one / has_many, I'm getting my peer's
+        # natural_id and have to return all valid_from of records that are
+        # pointing to it.
+        queries[klass] ||= {}
+        queries[klass][association.foreign_key] ||= []
+        queries[klass][association.foreign_key] += natural_ids
+
+        # My own natural_ids for going further are the one's of the records that
+        # are pointing to my peer.
+        my_natural_ids = klass.unscoped.select(:natural_id).where(association.foreign_key => natural_ids).collect(&:natural_id)
+      end
+
+      klass.versioned_associations.each do |_name, nested_association|
+        if nested_association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+          # I have an association that I am pointing to. I'll have to supply
+          # them with all the natural_ids I'm pointing to.
+
+          table = Arel::Table.new(klass.table_name)
+
+          natural_fks = klass
+                        .unscoped
+                        .select(nested_association.foreign_key)
+                        .where(natural_id: my_natural_ids)
+                        .where(table[nested_association.foreign_key].not_eq(nil))
+                        .collect(&nested_association.foreign_key.to_sym)
+
+          queries = merge_queries(
+            queries,
+            snaptime_queries(nested_association.klass, natural_fks, nested_association, visited_natural_ids_by_assoc)
+          )
+        elsif nested_association.is_a?(ActiveRecord::Reflection::HasOneReflection) || nested_association.is_a?(ActiveRecord::Reflection::HasManyReflection)
+          # I have an association that points to me. I'll have to supply my
+          # natural_ids of interest.
+          queries = merge_queries(
+            queries,
+            snaptime_queries(nested_association.klass, my_natural_ids, nested_association, visited_natural_ids_by_assoc)
+          )
+        else
+          fail "Unsupported relation type #{nested_association.class}."
+        end
+      end
+
+      return queries
+    end
+
+    private_class_method :snaptime_queries
+
+    def self.merge_queries(a, b)
+      a.deep_merge b do |_key, val_a, val_b|
+        (val_a + val_b).uniq
+      end
+    end
+
+    private_class_method :merge_queries
+
+    def self.union_selects(*selects)
+      stmt = selects.collect(&:to_sql).collect { |sql| "(#{sql})" }.join("\nUNION\n")
+      return "(#{stmt})"
+    end
+
+    private_class_method :union_selects
+  end
+end

data/lib/snaptime/migration_helpers.rb

@@ -0,0 +1,54 @@
+module Snaptime
+  module MigrationHelpers
+    def self.load
+      ActiveRecord::ConnectionAdapters::Table.class_eval do
+        include SchemaStatements::Table
+      end
+
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+        include SchemaStatements::TopLevel
+      end
+    end
+
+    module SchemaStatements
+      module Table
+        def versionize
+          column :natural_id, :integer
+          column :valid_from, :timestamp, precision: 3
+          column :valid_to, :timestamp, precision: 3
+          column :deleted, :boolean, null: false, default: 0
+
+          index :natural_id
+          index :valid_from
+          index :valid_to
+
+          index %i(natural_id valid_to), unique: true
+
+          @base.execute %(
+            ALTER TABLE "#{name.to_s.upcase}"
+            ADD CONSTRAINT "#{name.to_s.upcase}_VCVD" CHECK (
+              VALID_TO IS NULL OR VALID_FROM <= VALID_TO
+            )
+          )
+        end
+
+        def unversionize
+          remove :natural_id
+          remove :valid_from
+          remove :valid_to
+          remove :deleted
+        end
+      end
+
+      module TopLevel
+        def versionize_table(table_name)
+          change_table table_name, &:versionize
+        end
+
+        def unversionize_table(table_name)
+          change_table table_name, &:unversionize
+        end
+      end
+    end
+  end
+end

data/lib/snaptime/railtie.rb

@@ -0,0 +1,23 @@
+module Snaptime
+  class Railtie < Rails::Railtie
+    railtie_name :snaptime
+
+    initializer :snaptime do
+      ActiveSupport.on_load :active_record do
+        Snaptime::MigrationHelpers.load
+      end
+
+      ActiveRecord::Base.send :include, Snaptime::BaseArMixin
+
+      ActiveRecord::Base.send :after_commit do
+        Snaptime.after_commit_or_rollback
+      end
+
+      ActiveRecord::Base.send :after_rollback do
+        Snaptime.after_commit_or_rollback
+      end
+
+      Snaptime.register_consolidation_field(:valid_from)
+    end
+  end
+end

data/lib/snaptime/record_cloner.rb

@@ -0,0 +1,72 @@
+module Snaptime
+  class RecordCloner
+    def self.clone_record!(record, override_attributes: {}, return_record: true)
+      override_attribute_keys = override_attributes.keys
+
+      table = record.class.arel_table
+
+      cloned_column_names = record.class.column_names - [record.class.primary_key] - override_attribute_keys.collect(&:to_s)
+
+      # ---------------------------------------------------------------
+      # Prepare select statement
+      # ---------------------------------------------------------------
+      select = Arel::SelectManager.new(record.class)
+      select.from table
+
+      # Add primary key
+      clone_id = next_id_for(record)
+      select.project clone_id
+
+      # Project custom column values
+      override_attribute_keys.each do |key|
+        select.project record.class.connection.quote(override_attributes[key])
+      end
+
+      # Project remaining (cloned) column values
+      cloned_column_names.each do |col|
+        select.project table[col.to_sym]
+      end
+
+      # Where statement for selecting the original record
+      select.where(table[record.class.primary_key.to_sym].eq(record.send(record.class.primary_key)))
+
+      # ---------------------------------------------------------------
+      # Prepare insert statement
+      # ---------------------------------------------------------------
+      insert = Arel::InsertManager.new
+      insert.into table
+      insert.select select
+
+      # Add primary key column name
+      insert.columns << table[record.class.primary_key.to_sym]
+
+      # Add override column names
+      override_attribute_keys.each do |attr|
+        insert.columns << table[attr.to_sym]
+      end
+
+      # Add remaining (cloned) column names
+      cloned_column_names.each do |c|
+        insert.columns << table[c.to_sym]
+      end
+
+      # ---------------------------------------------------------------
+      # Execute statement
+      # ---------------------------------------------------------------
+      record.class.connection.execute(insert.to_sql)
+
+      if return_record
+        return record.class.find(clone_id)
+      else
+        return nil
+      end
+    end
+
+    def self.next_id_for(record)
+      # See https://github.com/rsim/oracle-enhanced/issues/1733
+      ActiveRecord::Base.uncached do
+        record.class.connection.next_sequence_value(record.class.sequence_name)
+      end
+    end
+  end
+end

data/lib/snaptime/relations.rb

@@ -0,0 +1,26 @@
+# rubocop: disable Style/PredicateName
+
+module Snaptime
+  module Relations
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :versioned_associations
+      self.versioned_associations = {}.freeze
+    end
+
+    module ClassMethods
+      def has_one_versioned(name, scope = nil, options = {})
+        RelationsBuilder.build_versioned_relation(self, :has_one, name, scope, options)
+      end
+
+      def has_many_versioned(name, scope = nil, options = {}, &extension)
+        RelationsBuilder.build_versioned_relation(self, :has_many, name, scope, options, &extension)
+      end
+
+      def belongs_to_versioned(name, scope = nil, options = {})
+        RelationsBuilder.build_versioned_relation(self, :belongs_to, name, scope, options)
+      end
+    end
+  end
+end

data/lib/snaptime/relations_builder.rb

@@ -0,0 +1,32 @@
+# rubocop: disable Metrics/ParameterLists
+
+module Snaptime
+  module RelationsBuilder
+    def self.build_versioned_relation(klass, macro, name, scope = nil, options = {}, &extension)
+      if scope.is_a?(Hash)
+        options = scope
+        scope   = nil
+      end
+
+      options[:primary_key] ||= (klass.versioned? ? :natural_id : klass.primary_key)
+
+      versioned_scope = proc do
+        rel = spawn.unscope(where: %i(valid_from valid_to))
+        rel = rel.merge(scope) unless scope.nil?
+        rel._at_explicit_snaptime(Snaptime.snaptime)
+      end
+
+      klass.send(macro, name, versioned_scope, options, &extension)
+
+      reflection = klass.reflect_on_association(name)
+
+      unless reflection.klass.versioned?
+        fail Exceptions::AssociationTargetNotVersioned, reflection.klass
+      end
+
+      klass.versioned_associations = klass.versioned_associations.merge(
+        name => reflection
+      )
+    end
+  end
+end

data/lib/snaptime/versioned.rb

@@ -0,0 +1,49 @@
+module Snaptime
+  module Versioned
+    extend ActiveSupport::Concern
+
+    include Scopes
+    include Relations
+
+    module ClassMethods
+      def delete(*_args)
+        fail Exceptions::DeleteMethodsAreNotAvailable
+      end
+
+      def delete_all(*_args)
+        fail Exceptions::DeleteMethodsAreNotAvailable
+      end
+
+      def versioned?
+        true
+      end
+    end
+
+    def _run_create_callbacks(*args, &block)
+      super do
+        ArHooks.before_create(self)
+        yield
+        ArHooks.after_create(self)
+      end
+    end
+
+    # To make sure our before_update always runs after all other before_update
+    # methods, we override {_run_update_callbacks}. This prevents cases where an
+    # after_update callback changes the record after it has already been
+    # detected as no-changed. In this case, no shadow clone would be created.
+    def _run_update_callbacks(*args, &block)
+      super do
+        ArHooks.before_update(self)
+        yield
+      end
+    end
+
+    def destroy
+      ArHooks.destroy(self)
+    end
+
+    def delete
+      fail Exceptions::DeleteMethodsAreNotAvailable
+    end
+  end
+end

data/lib/snaptime/versioned/scopes.rb

@@ -0,0 +1,64 @@
+module Snaptime
+  module Versioned
+    module Scopes
+      extend ActiveSupport::Concern
+
+      included do
+        default_scope do
+          current_version
+        end
+      end
+
+      module ClassMethods
+        def current_version
+          snaptime = Snaptime.snaptime
+          _at_explicit_snaptime(snaptime)
+        end
+
+        def _at_explicit_snaptime(snaptime = nil)
+          if snaptime.nil?
+            where(valid_to: nil, deleted: false)
+          else
+            where(
+              arel_table[:valid_from].lteq(snaptime).and(
+                arel_table[:valid_to].eq(nil).or(
+                  arel_table[:valid_to].gteq(snaptime)
+                )
+              ).and(
+                arel_table[:deleted].eq(false)
+              )
+            )
+          end
+        end
+
+        def at_snaptime
+          _at_explicit_snaptime Snaptime.snaptime
+        end
+      end
+
+      def snaptimes
+        Harvester.harvest_for(self)
+      end
+
+      def with_snaptime(snaptime = nil)
+        Snaptime.with_snaptime(snaptime) do
+          yield at_snaptime
+        end
+      end
+
+      def at_snaptime
+        _at_explicit_snaptime Snaptime.snaptime
+      end
+
+      def all_versions
+        self.class.unscoped.where('natural_id = ?', natural_id)
+      end
+
+      private
+
+      def _at_explicit_snaptime(snaptime = nil)
+        all_versions._at_explicit_snaptime(snaptime).first
+      end
+    end
+  end
+end

data/lib/snaptime/virtual_models/snaptime.rb

@@ -0,0 +1,52 @@
+module Snaptime
+  module VirtualModels
+    class Snaptime < ActiveRecord::Base
+      def self.load_schema
+        columns_hash
+      end
+
+      def self.columns
+        [
+          ActiveRecord::ConnectionAdapters::Column.new('valid_from', nil, ActiveRecord::Base.connection.send(:lookup_cast_type, :timestamp))
+        ]
+      end
+
+      def self.columns_hash
+        Hash[columns.map { |c| [c.name, c] }]
+      end
+
+      self.primary_key = :valid_from
+
+      def record_lookups
+        read_attribute(:record_lookups).split(';')
+      end
+
+      def records
+        to_fetch = {}
+
+        record_lookups.collect do |identifier|
+          klass_name, id = identifier.split(',')
+
+          to_fetch[klass_name] ||= Set.new
+          to_fetch[klass_name] << id
+        end
+
+        records = []
+
+        to_fetch.each do |klass_name, ids|
+          records += klass_name.constantize.unscoped.find(ids.to_a)
+        end
+
+        return records
+      end
+
+      def model_names
+        read_attribute(:model_names).split(',')
+      end
+
+      def models
+        model_names.collect(&:constantize)
+      end
+    end
+  end
+end

data/snaptime.gemspec

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+# stub: snaptime 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "snaptime".freeze
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Sitrox".freeze]
+  s.date = "2019-04-03"
+  s.files = [".gitignore".freeze, ".releaser_config".freeze, "Gemfile".freeze, "Gemfile.lock".freeze, "LICENSE".freeze, "README.md".freeze, "Rakefile".freeze, "VERSION".freeze, "lib/snaptime.rb".freeze, "lib/snaptime/ar_hooks.rb".freeze, "lib/snaptime/base_ar_mixin.rb".freeze, "lib/snaptime/exceptions.rb".freeze, "lib/snaptime/harvester.rb".freeze, "lib/snaptime/migration_helpers.rb".freeze, "lib/snaptime/railtie.rb".freeze, "lib/snaptime/record_cloner.rb".freeze, "lib/snaptime/relations.rb".freeze, "lib/snaptime/relations_builder.rb".freeze, "lib/snaptime/versioned.rb".freeze, "lib/snaptime/versioned/scopes.rb".freeze, "lib/snaptime/virtual_models/snaptime.rb".freeze, "snaptime.gemspec".freeze]
+  s.rubygems_version = "2.5.2.3".freeze
+  s.summary = "Multi-threaded job backend with database queuing for ruby.".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>.freeze, ["~> 2.0"])
+      s.add_development_dependency(%q<rake>.freeze, [">= 0"])
+      s.add_development_dependency(%q<rubocop>.freeze, ["= 0.51.0"])
+      s.add_development_dependency(%q<minitest>.freeze, [">= 0"])
+      s.add_development_dependency(%q<mysql2>.freeze, [">= 0"])
+      s.add_development_dependency(%q<benchmark-ips>.freeze, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>.freeze, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>.freeze, [">= 0"])
+      s.add_runtime_dependency(%q<request_store>.freeze, [">= 0"])
+    else
+      s.add_dependency(%q<bundler>.freeze, ["~> 2.0"])
+      s.add_dependency(%q<rake>.freeze, [">= 0"])
+      s.add_dependency(%q<rubocop>.freeze, ["= 0.51.0"])
+      s.add_dependency(%q<minitest>.freeze, [">= 0"])
+      s.add_dependency(%q<mysql2>.freeze, [">= 0"])
+      s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
+      s.add_dependency(%q<activesupport>.freeze, [">= 0"])
+      s.add_dependency(%q<activerecord>.freeze, [">= 0"])
+      s.add_dependency(%q<request_store>.freeze, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bundler>.freeze, ["~> 2.0"])
+    s.add_dependency(%q<rake>.freeze, [">= 0"])
+    s.add_dependency(%q<rubocop>.freeze, ["= 0.51.0"])
+    s.add_dependency(%q<minitest>.freeze, [">= 0"])
+    s.add_dependency(%q<mysql2>.freeze, [">= 0"])
+    s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
+    s.add_dependency(%q<activesupport>.freeze, [">= 0"])
+    s.add_dependency(%q<activerecord>.freeze, [">= 0"])
+    s.add_dependency(%q<request_store>.freeze, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: snaptime
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sitrox
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".releaser_config"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/snaptime.rb
+- lib/snaptime/ar_hooks.rb
+- lib/snaptime/base_ar_mixin.rb
+- lib/snaptime/exceptions.rb
+- lib/snaptime/harvester.rb
+- lib/snaptime/migration_helpers.rb
+- lib/snaptime/railtie.rb
+- lib/snaptime/record_cloner.rb
+- lib/snaptime/relations.rb
+- lib/snaptime/relations_builder.rb
+- lib/snaptime/versioned.rb
+- lib/snaptime/versioned/scopes.rb
+- lib/snaptime/virtual_models/snaptime.rb
+- snaptime.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Multi-threaded job backend with database queuing for ruby.
+test_files: []