rails_event_store_active_record 1.3.1 → 2.0.0

data/Makefile

@@ -1,9 +1,15 @@
 GEM_VERSION  = $(shell cat ../RES_VERSION)
 GEM_NAME     = rails_event_store_active_record
 REQUIRE      = $(GEM_NAME)
-IGNORE       = RailsEventStoreActiveRecord::IndexViolationDetector\#detect \
+IGNORE       = RailsEventStoreActiveRecord::IndexViolationDetector\#initialize \
+               RailsEventStoreActiveRecord::IndexViolationDetector\#detect \
+               RailsEventStoreActiveRecord::IndexViolationDetector\#detect_mysql \
+               RailsEventStoreActiveRecord::IndexViolationDetector\#detect_postgres \
                RailsEventStoreActiveRecord::PgLinearizedEventRepository* \
-               RailsEventStoreActiveRecord::EventRepository\#update_messages
+               RailsEventStoreActiveRecord::EventRepository\#update_messages \
+               RailsEventStoreActiveRecord::WithAbstractBaseClass\#build_event_klass \
+               RailsEventStoreActiveRecord::WithAbstractBaseClass\#build_stream_klass
+
 SUBJECT      ?= RailsEventStoreActiveRecord*
 DATABASE_URL ?= sqlite3::memory:
 
@@ -13,16 +19,3 @@ include ../support/make/mutant.mk
 include ../support/make/gem.mk
 include ../support/make/help.mk
 
-install: install-gemfiles
-
-remove-lock: remove-lockfiles
-
-install-gemfiles:
-	@BUNDLE_GEMFILE=../support/bundler/Gemfile.0_33_0 bundle check || BUNDLE_GEMFILE=../support/bundler/Gemfile.0_33_0 bundle install
-	@BUNDLE_GEMFILE=../support/bundler/Gemfile.0_34_0 bundle check || BUNDLE_GEMFILE=../support/bundler/Gemfile.0_34_0 bundle install
-	@BUNDLE_GEMFILE=../support/bundler/Gemfile.0_35_0 bundle check || BUNDLE_GEMFILE=../support/bundler/Gemfile.0_35_0 bundle install
-
-remove-lockfiles:
-	-rm ../support/bundler/Gemfile.0_33_0.lock
-	-rm ../support/bundler/Gemfile.0_34_0.lock
-	-rm ../support/bundler/Gemfile.0_35_0.lock

data/lib/rails_event_store_active_record/event.rb

@@ -11,6 +11,6 @@ module RailsEventStoreActiveRecord
   class EventInStream < ::ActiveRecord::Base
     self.primary_key = :id
     self.table_name = 'event_store_events_in_streams'
-    belongs_to :event
+    belongs_to :event, primary_key: :event_id
   end
 end

data/lib/rails_event_store_active_record/event_repository.rb

@@ -6,33 +6,37 @@ require 'activerecord-import'
 module RailsEventStoreActiveRecord
   class EventRepository
     POSITION_SHIFT = 1
-    SERIALIZED_GLOBAL_STREAM_NAME = "all".freeze
 
-    def initialize
-      @repo_reader = EventRepositoryReader.new
+    def initialize(model_factory: WithDefaultModels.new, serializer:)
+      @serializer  = serializer
+
+      @event_klass, @stream_klass = model_factory.call
+      @repo_reader = EventRepositoryReader.new(@event_klass, @stream_klass, serializer)
+      @index_violation_detector = IndexViolationDetector.new(@event_klass.table_name, @stream_klass.table_name)
     end
 
-    def append_to_stream(events, stream, expected_version)
-      records, event_ids = [], []
-      Array(events).each do |event|
-        records << build_event_hash(event)
-        event_ids << event.event_id
+    def append_to_stream(records, stream, expected_version)
+      hashes    = []
+      event_ids = []
+      Array(records).each do |record|
+        hashes    << import_hash(record, record.serialize(serializer))
+        event_ids << record.event_id
       end
-      add_to_stream(event_ids, stream, expected_version, true) do
-        Event.import(records)
+      add_to_stream(event_ids, stream, expected_version) do
+        @event_klass.import(hashes)
       end
     end
 
     def link_to_stream(event_ids, stream, expected_version)
       event_ids = Array(event_ids)
-      (event_ids - Event.where(id: event_ids).pluck(:id)).each do |id|
+      (event_ids - @event_klass.where(event_id: event_ids).pluck(:event_id)).each do |id|
         raise RubyEventStore::EventNotFound.new(id)
       end
-      add_to_stream(event_ids, stream, expected_version, nil)
+      add_to_stream(event_ids, stream, expected_version)
     end
 
     def delete_stream(stream)
-      EventInStream.where(stream: stream.name).delete_all
+      @stream_klass.where(stream: stream.name).delete_all
     end
 
     def has_event?(event_id)
@@ -51,49 +55,41 @@ module RailsEventStoreActiveRecord
       @repo_reader.count(specification)
     end
 
-    def update_messages(messages)
-      hashes = messages.map(&:to_h)
-      hashes.each{|h| h[:id] = h.delete(:event_id) }
-      for_update = messages.map(&:event_id)
+    def update_messages(records)
+      hashes  = Array(records).map{|record| import_hash(record, record.serialize(serializer)) }
+      for_update = records.map(&:event_id)
       start_transaction do
-        existing = Event.where(id: for_update).pluck(:id)
-        (for_update - existing).each{|id| raise RubyEventStore::EventNotFound.new(id) }
-        Event.import(hashes, on_duplicate_key_update: [:data, :metadata, :event_type])
+        existing = @event_klass.where(event_id: for_update).pluck(:event_id, :id).to_h
+        (for_update - existing.keys).each{|id| raise RubyEventStore::EventNotFound.new(id) }
+        hashes.each { |h| h[:id] = existing.fetch(h.fetch(:event_id)) }
+        @event_klass.import(hashes, on_duplicate_key_update: [:data, :metadata, :event_type, :valid_at])
       end
     end
 
     def streams_of(event_id)
-      EventInStream.where(event_id: event_id)
-        .where.not(stream: SERIALIZED_GLOBAL_STREAM_NAME)
+      @stream_klass.where(event_id: event_id)
         .pluck(:stream)
         .map{|name| RubyEventStore::Stream.new(name)}
     end
 
     private
+    attr_reader :serializer
 
-    def add_to_stream(event_ids, stream, expected_version, include_global)
-      last_stream_version = ->(stream_) { EventInStream.where(stream: stream_.name).order("position DESC").first.try(:position) }
+    def add_to_stream(event_ids, stream, expected_version)
+      last_stream_version = ->(stream_) { @stream_klass.where(stream: stream_.name).order("position DESC").first.try(:position) }
       resolved_version = expected_version.resolve_for(stream, last_stream_version)
 
       start_transaction do
         yield if block_given?
-        in_stream = event_ids.flat_map.with_index do |event_id, index|
-          position = compute_position(resolved_version, index)
-          collection = []
-          collection.unshift({
-            stream: SERIALIZED_GLOBAL_STREAM_NAME,
-            position: nil,
-            event_id: event_id,
-          }) if include_global
-          collection.unshift({
+        in_stream = event_ids.map.with_index do |event_id, index|
+          {
             stream:   stream.name,
-            position: position,
-            event_id: event_id
-          }) unless stream.global?
-          collection
+            position: compute_position(resolved_version, index),
+            event_id: event_id,
+          }
         end
         fill_ids(in_stream)
-        EventInStream.import(in_stream)
+        @stream_klass.import(in_stream) unless stream.global?
       end
       self
     rescue ActiveRecord::RecordNotUnique => e
@@ -114,24 +110,30 @@ module RailsEventStoreActiveRecord
     end
 
     def detect_index_violated(message)
-      IndexViolationDetector.new.detect(message)
+      @index_violation_detector.detect(message)
     end
 
-    def build_event_hash(serialized_record)
+    def import_hash(record, serialized_record)
       {
-        id:         serialized_record.event_id,
+        event_id:   serialized_record.event_id,
         data:       serialized_record.data,
         metadata:   serialized_record.metadata,
-        event_type: serialized_record.event_type
+        event_type: serialized_record.event_type,
+        created_at: record.timestamp,
+        valid_at:   optimize_timestamp(record.valid_at, record.timestamp),
       }
     end
 
+    def optimize_timestamp(valid_at, created_at)
+      valid_at unless valid_at.eql?(created_at)
+    end
+
     # Overwritten in a sub-class
     def fill_ids(_in_stream)
     end
 
     def start_transaction(&block)
-      ActiveRecord::Base.transaction(requires_new: true, &block)
+      @event_klass.transaction(requires_new: true, &block)
     end
   end
 

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -3,92 +3,156 @@
 module RailsEventStoreActiveRecord
   class EventRepositoryReader
 
+    def initialize(event_klass, stream_klass, serializer)
+      @event_klass = event_klass
+      @stream_klass = stream_klass
+      @serializer = serializer
+    end
+
     def has_event?(event_id)
-      Event.exists?(id: event_id)
+      @event_klass.exists?(event_id: event_id)
     end
 
     def last_stream_event(stream)
-      record = EventInStream.where(stream: stream.name).order('position DESC, id DESC').first
-      record && build_serialized_record(record)
+      record_ = @stream_klass.where(stream: stream.name).order('position DESC, id DESC').first
+      record(record_) if record_
     end
 
     def read(spec)
-      raise RubyEventStore::ReservedInternalName if spec.stream.name.eql?(EventRepository::SERIALIZED_GLOBAL_STREAM_NAME)
-
       stream = read_scope(spec)
 
       if spec.batched?
         batch_reader = ->(offset_id, limit) do
-          records = offset_id.nil? ? stream.limit(limit) : stream.where(start_offset_condition(spec, offset_id)).limit(limit)
-          [records.map(&method(:build_serialized_record)), records.last]
+          search_in = spec.stream.global? ? @event_klass.table_name : @stream_klass.table_name
+          records = offset_id.nil? ? stream.limit(limit) : stream.where(start_offset_condition(spec, offset_id, search_in)).limit(limit)
+          [records.map(&method(:record)), records.last]
         end
         BatchEnumerator.new(spec.batch_size, spec.limit, batch_reader).each
       elsif spec.first?
-        record = stream.first
-        build_serialized_record(record) if record
+        record_ = stream.first
+        record(record_) if record_
       elsif spec.last?
-        record = stream.last
-        build_serialized_record(record) if record
+        record_ = stream.last
+        record(record_) if record_
       else
-        stream.map(&method(:build_serialized_record)).each
+        stream.map(&method(:record)).each
       end
     end
 
     def count(spec)
-      raise RubyEventStore::ReservedInternalName if spec.stream.name.eql?(EventRepository::SERIALIZED_GLOBAL_STREAM_NAME)
-
       read_scope(spec).count
     end
 
     private
+    attr_reader :serializer
 
     def read_scope(spec)
-      stream = EventInStream.preload(:event).where(stream: normalize_stream_name(spec))
-      stream = stream.where(event_id: spec.with_ids) if spec.with_ids?
-      stream = stream.joins(:event).where(event_store_events: {event_type: spec.with_types}) if spec.with_types?
-      stream = stream.order(position: order(spec)) unless spec.stream.global?
-      stream = stream.limit(spec.limit) if spec.limit?
-      stream = stream.where(start_condition(spec)) if spec.start
-      stream = stream.where(stop_condition(spec)) if spec.stop
-      stream = stream.order(id: order(spec))
-      stream
+      if spec.stream.global?
+        stream = @event_klass
+        stream = stream.where(event_id: spec.with_ids)                           if spec.with_ids?
+        stream = stream.where(event_type: spec.with_types)                       if spec.with_types?
+        stream = ordered(stream, spec)
+        stream = stream.limit(spec.limit)                                        if spec.limit?
+        stream = stream.where(start_condition_in_global_stream(spec))            if spec.start
+        stream = stream.where(stop_condition_in_global_stream(spec))             if spec.stop
+        stream = stream.where(older_than_condition(spec))          if spec.older_than
+        stream = stream.where(older_than_or_equal_condition(spec)) if spec.older_than_or_equal
+        stream = stream.where(newer_than_condition(spec))          if spec.newer_than
+        stream = stream.where(newer_than_or_equal_condition(spec)) if spec.newer_than_or_equal
+        stream.order(id: order(spec))
+      else
+        stream = @stream_klass.preload(:event).where(stream: spec.stream.name)
+        stream = stream.where(event_id: spec.with_ids)                                                if spec.with_ids?
+        stream = stream.where(@event_klass.table_name => {event_type: spec.with_types}) if spec.with_types?
+        stream = ordered(stream.joins(:event), spec)
+        stream = stream.order(position: order(spec), id: order(spec))
+        stream = stream.limit(spec.limit)                                        if spec.limit?
+        stream = stream.where(start_condition(spec))                             if spec.start
+        stream = stream.where(stop_condition(spec))                              if spec.stop
+        stream = stream.where(older_than_condition(spec))          if spec.older_than
+        stream = stream.where(older_than_or_equal_condition(spec)) if spec.older_than_or_equal
+        stream = stream.where(newer_than_condition(spec))          if spec.newer_than
+        stream = stream.where(newer_than_or_equal_condition(spec)) if spec.newer_than_or_equal
+        stream
+      end
     end
 
-    def normalize_stream_name(specification)
-      specification.stream.global? ? EventRepository::SERIALIZED_GLOBAL_STREAM_NAME : specification.stream.name
+    def ordered(stream, spec)
+      case spec.time_sort_by
+      when :as_at
+        stream.order("#{@event_klass.table_name}.created_at #{order(spec)}")
+      when :as_of
+        stream.order("#{@event_klass.table_name}.valid_at #{order(spec)}")
+      else
+        stream
+      end
     end
 
-    def start_offset_condition(specification, record_id)
-      condition = specification.forward? ? 'event_store_events_in_streams.id > ?' : 'event_store_events_in_streams.id < ?'
+    def start_offset_condition(specification, record_id, search_in)
+      condition = "#{search_in}.id #{specification.forward? ? '>' : '<'} ?"
       [condition, record_id]
     end
 
-    def stop_offset_condition(specification, record_id)
-      condition = specification.forward? ? 'event_store_events_in_streams.id < ?' : 'event_store_events_in_streams.id > ?'
+    def stop_offset_condition(specification, record_id, search_in)
+      condition = "#{search_in}.id #{specification.forward? ? '<' : '>'} ?"
       [condition, record_id]
     end
 
     def start_condition(specification)
       start_offset_condition(specification,
-        EventInStream.find_by!(event_id: specification.start, stream: normalize_stream_name(specification)))
+        @stream_klass.find_by!(event_id: specification.start, stream: specification.stream.name),
+        @stream_klass.table_name)
     end
 
     def stop_condition(specification)
       stop_offset_condition(specification,
-        EventInStream.find_by!(event_id: specification.stop, stream: normalize_stream_name(specification)))
+        @stream_klass.find_by!(event_id: specification.stop, stream: specification.stream.name),
+        @stream_klass.table_name)
+    end
+
+    def start_condition_in_global_stream(specification)
+      start_offset_condition(specification,
+        @event_klass.find_by!(event_id: specification.start),
+        @event_klass.table_name)
+    end
+
+    def stop_condition_in_global_stream(specification)
+      stop_offset_condition(specification,
+        @event_klass.find_by!(event_id: specification.stop),
+        @event_klass.table_name)
+    end
+
+    def older_than_condition(specification)
+      ["#{@event_klass.table_name}.created_at < ?", specification.older_than]
+    end
+
+    def older_than_or_equal_condition(specification)
+      ["#{@event_klass.table_name}.created_at <= ?", specification.older_than_or_equal]
+    end
+
+    def newer_than_condition(specification)
+      ["#{@event_klass.table_name}.created_at > ?", specification.newer_than]
+    end
+
+    def newer_than_or_equal_condition(specification)
+      ["#{@event_klass.table_name}.created_at >= ?", specification.newer_than_or_equal]
     end
 
     def order(spec)
       spec.forward? ? 'ASC' : 'DESC'
     end
 
-    def build_serialized_record(record)
+    def record(record)
+      record = record.event if @stream_klass === record
+
       RubyEventStore::SerializedRecord.new(
-        event_id: record.event.id,
-        metadata: record.event.metadata,
-        data: record.event.data,
-        event_type: record.event.event_type
-      )
+        event_id: record.event_id,
+        metadata: record.metadata,
+        data: record.data,
+        event_type: record.event_type,
+        timestamp: record.created_at.iso8601(RubyEventStore::TIMESTAMP_PRECISION),
+        valid_at: (record.valid_at || record.created_at).iso8601(RubyEventStore::TIMESTAMP_PRECISION),
+      ).deserialize(serializer)
     end
   end
 

data/lib/rails_event_store_active_record/generators/{limit_for_event_id_generator.rb → add_valid_at_generator.rb}

@@ -6,11 +6,11 @@ rescue LoadError
 end
 
 module RailsEventStoreActiveRecord
-  class LimitForEventIdGenerator < Rails::Generators::Base
+  class AddValidAtGenerator < Rails::Generators::Base
     source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
 
     def create_migration
-      template "limit_for_event_id_template.rb", "db/migrate/#{timestamp}_limit_for_event_id.rb"
+      template "add_valid_at_template.rb", "db/migrate/#{timestamp}_add_valid_at.rb"
     end
 
     private

data/lib/rails_event_store_active_record/generators/{index_by_event_type_generator.rb → created_at_precision_generator.rb}

@@ -6,11 +6,11 @@ rescue LoadError
 end
 
 module RailsEventStoreActiveRecord
-  class IndexByEventTypeGenerator < Rails::Generators::Base
+  class CreatedAtPrecisionGenerator < Rails::Generators::Base
     source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
 
     def create_migration
-      template "index_by_event_type_template.rb", "db/migrate/#{timestamp}_index_by_event_type.rb"
+      template "created_at_precision_template.rb", "db/migrate/#{timestamp}_created_at_precision.rb"
     end
 
     private

data/lib/rails_event_store_active_record/generators/{binary_data_and_metadata_generator.rb → no_global_stream_entries_generator.rb}

@@ -1,16 +1,14 @@
-# frozen_string_literal: true
-
 begin
   require 'rails/generators'
 rescue LoadError
 end
 
 module RailsEventStoreActiveRecord
-  class BinaryDataAndMetadataGenerator < Rails::Generators::Base
+  class NoGlobalStreamEntriesGenerator < Rails::Generators::Base
     source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
 
     def create_migration
-      template "binary_data_and_metadata_template.rb", "db/migrate/#{timestamp}_binary_data_and_metadata.rb"
+      template "no_global_stream_entries_template.rb", "db/migrate/#{timestamp}_no_global_stream_entries.rb"
     end
 
     private

data/lib/rails_event_store_active_record/generators/templates/add_valid_at_template.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AddValidAt < ActiveRecord::Migration<%= migration_version %>
+  def change
+    case ActiveRecord::Base.connection.adapter_name
+    when "PostgreSQL"
+       add_column :event_store_events, :valid_at, :datetime, null: true
+    else
+       add_column :event_store_events, :valid_at, :datetime, precision: 6, null: true
+    end
+
+    add_index :event_store_events, :valid_at
+  end
+end

data/lib/rails_event_store_active_record/generators/templates/create_event_store_events_template.rb

@@ -4,7 +4,7 @@ class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
   def change
     postgres = ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
     sqlite   = ActiveRecord::Base.connection.adapter_name == "SQLite"
-    rails_42 = Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("5.0.0")
+
     enable_extension "pgcrypto" if postgres
     create_table(:event_store_events_in_streams, force: false) do |t|
       t.string      :stream,      null: false
@@ -14,32 +14,38 @@ class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
       else
         t.references :event, null: false, type: :string, limit: 36
       end
-      t.datetime    :created_at,  null: false
+      if postgres
+        t.datetime    :created_at,  null: false
+      else
+        t.datetime    :created_at,  null: false, precision: 6
+      end
     end
     add_index :event_store_events_in_streams, [:stream, :position], unique: true
     add_index :event_store_events_in_streams, [:created_at]
     add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
 
     if postgres
-      create_table(:event_store_events, id: :uuid, default: 'gen_random_uuid()', force: false) do |t|
+      create_table(:event_store_events, force: false) do |t|
+        t.references  :event,       null: false, type: :uuid
         t.string      :event_type,  null: false
         t.<%= data_type %>      :metadata
         t.<%= data_type %>      :data,        null: false
         t.datetime    :created_at,  null: false
+        t.datetime    :valid_at,    null: true
       end
     else
-      create_table(:event_store_events, id: false, force: false) do |t|
-        t.string :id, limit: 36, primary_key: true, null: false
+      create_table(:event_store_events, force: false) do |t|
+        t.references  :event,       null: false, type: :string, limit: 36
         t.string      :event_type,  null: false
         t.binary      :metadata
         t.binary      :data,        null: false
-        t.datetime    :created_at,  null: false
-      end
-      if sqlite && rails_42
-        add_index :event_store_events, :id, unique: true
+        t.datetime    :created_at,  null: false, precision: 6
+        t.datetime    :valid_at,    null: true,  precision: 6
       end
     end
+    add_index :event_store_events, :event_id, unique: true
     add_index :event_store_events, :created_at
+    add_index :event_store_events, :valid_at
     add_index :event_store_events, :event_type
   end
 end

data/lib/rails_event_store_active_record/generators/templates/created_at_precision_template.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class CreatedAtPrecision < ActiveRecord::Migration<%= migration_version %>
+  def change
+    case ActiveRecord::Base.connection.adapter_name
+    when "SQLite"
+      rename_table :event_store_events, :old_event_store_events
+      create_table(:event_store_events, id: false, force: false) do |t|
+        t.string :id, limit: 36, primary_key: true, null: false
+        t.string      :event_type,  null: false
+        t.binary      :metadata
+        t.binary      :data,        null: false
+        t.datetime    :created_at,  null: false, precision: 6
+      end
+      add_index :event_store_events, :created_at
+      add_index :event_store_events, :event_type
+      execute <<-SQL
+        INSERT INTO event_store_events(id, event_type, metadata, data, created_at)
+        SELECT id, event_type, metadata, data, created_at FROM old_event_store_events;
+      SQL
+      drop_table :old_event_store_events
+
+      rename_table :event_store_events_in_streams, :old_event_store_events_in_streams
+      create_table(:event_store_events_in_streams, force: false) do |t|
+        t.string      :stream,      null: false
+        t.integer     :position,    null: true
+        t.references  :event,       null: false, type: :string, limit: 36
+        t.datetime    :created_at,  null: false, precision: 6
+      end
+      add_index :event_store_events_in_streams, [:stream, :position], unique: true
+      add_index :event_store_events_in_streams, [:created_at]
+      add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
+
+      execute <<-SQL
+        INSERT INTO event_store_events_in_streams(id, stream, position, event_id, created_at)
+        SELECT id, stream, position, event_id, created_at FROM old_event_store_events_in_streams;
+      SQL
+      drop_table :old_event_store_events_in_streams
+    when "PostgreSQL"
+    else
+      change_column :event_store_events,            :created_at, :datetime, precision: 6
+      change_column :event_store_events_in_streams, :created_at, :datetime, precision: 6
+    end
+  end
+end

data/lib/rails_event_store_active_record/generators/templates/no_global_stream_entries_template.rb

@@ -0,0 +1,59 @@
+class NoGlobalStreamEntries < ActiveRecord::Migration<%= migration_version %>
+  def change
+    case ActiveRecord::Base.connection.adapter_name
+    when "SQLite"
+      rename_table :event_store_events, :old_event_store_events
+      create_table(:event_store_events, force: false) do |t|
+        t.references  :event,       null: false, type: :string, limit: 36
+        t.string      :event_type,  null: false
+        t.binary      :metadata
+        t.binary      :data,        null: false
+        t.datetime    :created_at,  precision: 6, null: false
+        t.datetime    :valid_at,    precision: 6, null: true
+      end
+      add_index :event_store_events, :event_id, unique: true
+      add_index :event_store_events, :created_at
+      add_index :event_store_events, :valid_at
+      add_index :event_store_events, :event_type
+
+      execute <<-SQL
+        INSERT INTO event_store_events(event_id, event_type, metadata, data, created_at)
+        SELECT id, event_type, metadata, data, created_at FROM old_event_store_events;
+      SQL
+      drop_table :old_event_store_events
+    when "PostgreSQL"
+      rename_column :event_store_events, :id, :event_id
+      change_column_default :event_store_events, :event_id, nil
+      add_column :event_store_events, :id, :serial
+
+      execute <<~SQL
+        UPDATE event_store_events
+          SET id = event_store_events_in_streams.id
+          FROM event_store_events_in_streams
+          WHERE event_store_events.event_id = event_store_events_in_streams.event_id AND event_store_events_in_streams.stream = 'all';
+        UPDATE event_store_events
+          SET id = ese.new_id
+          FROM (SELECT id, row_number() OVER (ORDER BY id) AS new_id FROM event_store_events) ese
+          WHERE event_store_events.id = ese.id;
+        SELECT setval(pg_get_serial_sequence('event_store_events', 'id'), max(id)) FROM event_store_events;
+        ALTER TABLE event_store_events DROP CONSTRAINT event_store_events_pkey;
+        ALTER TABLE event_store_events ADD PRIMARY KEY (id);
+      SQL
+      add_index :event_store_events, :event_id, unique: true
+    else
+      rename_column :event_store_events, :id, :event_id
+      add_column :event_store_events, :id, :integer
+
+      execute <<-SQL
+        UPDATE event_store_events
+          INNER JOIN event_store_events_in_streams ON (event_store_events.event_id = event_store_events_in_streams.event_id)
+          SET event_store_events.id = event_store_events_in_streams.id
+          WHERE event_store_events_in_streams.stream = 'all';
+      SQL
+      execute "SET @row_number = 0"
+      execute "UPDATE event_store_events SET event_store_events.id = (@row_number:=@row_number + 1) ORDER BY id"
+      execute "ALTER TABLE event_store_events DROP PRIMARY KEY, ADD PRIMARY KEY (id), MODIFY id INT AUTO_INCREMENT"
+      add_index :event_store_events, :event_id, unique: true
+    end
+  end
+end