nexia_event_store 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 115b1bb8a9f14f799f97b9038cf9ae1ed8a9aacd
-  data.tar.gz: b1e31142a7fda060e2f4b2cd1a81a3c0cc8dc652
+  metadata.gz: 810f954e899ec5777b6f4b57431d9739734f8519
+  data.tar.gz: b0fc4fae467b95e007d317894206618d9ada5899
 SHA512:
-  metadata.gz: 46eac58f16227a98364a52a33c0c9d8f91c1dcbfd8047c52373e4a0d0ea131a6f16324a5ccd54b7c21d2781f6903b2c312dbba32ad951b55bdb1fe4cf2d72671
-  data.tar.gz: 1f6c50f1f137024ac13b1a683b68815ea34e7f833555a66624b9bb885f2917b96708d8f06749af111164756bd0822da0c16de56269703e914f7ea937a92f3385
+  metadata.gz: 74d45ebf5fe97fdb52e067b17885be10159e2a94200671b1fa106a75e90e6428e33a362ded5a481c92d762981c5e9cba56f60126960bc34216845ccea3306045
+  data.tar.gz: 58ed1ef36e12724c2ee1ea689af1eeb3d85164677c800aadac21a2ac11b20d92b09e590a05162595b1f44cc35afb2c2d95b71dacd2689e5dd3ed1c7587e60170

data/db/database.yml

@@ -35,8 +35,8 @@ test:
   postgres:
     <<: *postgres
     database: history_store
-    schema: event_store_gem_test
+    schema: es_test
   vertica:
     <<: *vertica
     database: history_store
-    schema: event_store_gem_test
+    schema: es_test

data/db/pg_migrations/003_add_agg_id_occurred_fqn_idx_to_event_store.rb

@@ -0,0 +1,10 @@
+require 'event_store'
+Sequel.migration do
+  no_transaction
+  change do
+    idx_name = "#{EventStore.schema}_#{EventStore.table_name}_aggregate_id_occurred_at_name_idx"
+    alter_table((EventStore.schema + "__" + EventStore.table_name).to_sym) do
+      add_index([:aggregate_id, :occurred_at, :fully_qualified_name], name: idx_name, concurrently: true)
+    end
+  end
+end

data/db/pg_migrations/004_add_fqn_lookup_table_to_event_store.rb

@@ -0,0 +1,68 @@
+require 'event_store'
+Sequel.migration do
+  no_transaction
+
+  event_store_table = (EventStore.schema + "__" + EventStore.table_name).to_sym
+  lookup_table =      (EventStore.schema + "__" + EventStore.lookup_table_name).to_sym
+
+  event_store_table_name = event_store_table.to_s.gsub(/__/, '.')
+  lookup_table_name      = lookup_table.to_s.gsub(/__/, '.')
+
+  up do
+    create_table(lookup_table) do
+      primary_key :id
+      String :fully_qualified_name, null: false, unique: true
+      index  :fully_qualified_name
+    end
+
+    run <<-"EOSQL"
+      INSERT INTO #{lookup_table_name} (fully_qualified_name)
+        SELECT DISTINCT fully_qualified_name FROM #{event_store_table_name}
+    EOSQL
+
+    alter_table(event_store_table) do
+      idx_name = "aggregate_id_occurred_at_fqn_id_idx"
+      add_foreign_key :fully_qualified_name_id, lookup_table, key: :id, null: false
+      add_index([:aggregate_id, :occurred_at, :fully_qualified_name_id], name: idx_name)
+    end
+
+    run <<-"EOSQL"
+      UPDATE #{event_store_table_name} AS event_store
+         SET fully_qualified_name_id = lookup.id
+        FROM #{lookup_table_name} AS lookup
+       WHERE lookup.fully_qualified_name = event_store.fully_qualified_name
+    EOSQL
+
+    alter_table(event_store_table) do
+      old_idx_name = "#{EventStore.schema}_#{EventStore.table_name}_aggregate_id_occurred_at_name_idx"
+      drop_index [:aggregate_id, :occurred_at, :fully_qualified_name], name: old_idx_name
+      drop_index :fully_qualified_name
+      drop_column :fully_qualified_name
+    end
+  end
+
+  down do
+    alter_table(event_store_table) do
+      idx_name = "#{EventStore.schema}_#{EventStore.table_name}_aggregate_id_occurred_at_name_idx"
+      old_idx_name = "aggregate_id_occurred_at_fqn_id_idx"
+
+      add_column :fully_qualified_name, String
+      add_index :fully_qualified_name
+      add_index([:aggregate_id, :occurred_at, :fully_qualified_name], name: idx_name)
+      drop_index old_idx_name
+    end
+
+    run <<-"EOSQL"
+      UPDATE #{event_store_table_name} AS event_store
+         SET fully_qualified_name = lookup.fully_qualified_name
+        FROM #{lookup_table_name} AS lookup
+       WHERE lookup.id = event_store.fully_qualified_name_id
+    EOSQL
+
+    alter_table(event_store_table) do
+      drop_foreign_key :fully_qualified_name_id
+    end
+
+    drop_table(lookup_table)
+  end
+end

data/lib/event_store/event_stream.rb

@@ -7,7 +7,10 @@ module EventStore
     def initialize aggregate
       @aggregate = aggregate
       @id = @aggregate.id
-      @event_table = EventStore.fully_qualified_table
+      @event_table_alias = "events"
+      @event_table = "#{EventStore.schema}__#{EventStore.table_name}".to_sym
+      @aliased_event_table = "#{event_table}___#{@event_table_alias}".to_sym
+      @names_table = EventStore.fully_qualified_names_table
     end
 
     def append(raw_events)
@@ -17,20 +20,38 @@ module EventStore
         event
       end
 
-      inserted_ids = events.multi_insert(prepared_events, return: :primary_key)
-      prepared_events.each_with_index do |event, idx|
-        event[:id] = inserted_ids[idx]
+      event_table = EventStore.db.from(@event_table)
+      prepared_events.each do |event|
+        event_hash = event.dup.reject! { |k,v| k == :fully_qualified_name }
+
+        begin
+          id = event_table.insert(event_hash)
+        rescue Sequel::NotNullConstraintViolation
+          fully_qualified_names.insert(fully_qualified_name: event[:fully_qualified_name])
+          id = event_table.insert(event_hash)
+        end
+
+        event[:id] = id
       end
 
       yield(prepared_events) if block_given?
     end
 
+    def fully_qualified_names
+      @fully_qualified_name_query ||= EventStore.db.from(@names_table)
+    end
+
     def events
-      @events_query ||= EventStore.db.from(@event_table).where(:aggregate_id => @id.to_s).order(:id)
+      @events_query ||= EventStore.db.from(@aliased_event_table)            \
+                          .where(:aggregate_id => @id.to_s)                 \
+                          .join(@names_table, id: :fully_qualified_name_id) \
+                          .order("#{@event_table_alias}__id".to_sym)        \
+                          .select_all(:events).select_append(:fully_qualified_name)
     end
 
     def events_from(event_id, max = nil)
-      events.limit(max).where{ id >= event_id.to_i }.all.map do |event|
+      # note: this depends on the events table being aliased to "events" above.
+      events.limit(max).where{events__id >= event_id.to_i }.all.map do |event|
         event[:serialized_event] = EventStore.unescape_bytea(event[:serialized_event])
         event
       end
@@ -69,18 +90,19 @@ module EventStore
     end
 
     def delete_events!
-      events.delete
+      EventStore.db.from(@event_table).where(:aggregate_id => @id.to_s).delete
     end
 
   private
 
     def prepare_event(raw_event)
       raise ArgumentError.new("Cannot Append a Nil Event") unless raw_event
-      { :aggregate_id         => raw_event.aggregate_id,
-        :occurred_at          => Time.parse(raw_event.occurred_at.to_s).utc, #to_s truncates microseconds, which brake Time equality
-        :serialized_event     => EventStore.escape_bytea(raw_event.serialized_event),
-        :fully_qualified_name => raw_event.fully_qualified_name,
-        :sub_key              => raw_event.sub_key
+      { :aggregate_id            => raw_event.aggregate_id,
+        :occurred_at             => Time.parse(raw_event.occurred_at.to_s).utc, #to_s truncates microseconds, which brake Time equality
+        :serialized_event        => EventStore.escape_bytea(raw_event.serialized_event),
+        :fully_qualified_name_id => EventStore.db.from(@names_table).where(fully_qualified_name: raw_event.fully_qualified_name).select(:id),
+        :fully_qualified_name    => raw_event.fully_qualified_name,
+        :sub_key                 => raw_event.sub_key
       }
     end
 

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 end

data/lib/event_store.rb

@@ -64,10 +64,18 @@ module EventStore
     @table_name ||= raw_db_config['table_name']
   end
 
+  def self.lookup_table_name
+    @lookup_table_name ||= raw_db_config['lookup_table_name'] || "fully_qualified_names"
+  end
+
   def self.fully_qualified_table
     @fully_qualified_table ||= Sequel.lit "#{schema}.#{table_name}"
   end
 
+  def self.fully_qualified_names_table
+    @fully_qualified_names_table ||= Sequel.lit "#{schema}.#{lookup_table_name}"
+  end
+
   def self.connected?
     !!EventStore.db
   end

data/spec/event_store/client_spec.rb

@@ -52,7 +52,7 @@ describe EventStore::Client do
         raw_stream = es_client.new(AGGREGATE_ID_ONE, :device).raw_event_stream
         raw_event = raw_stream.first
         expect(raw_event.class).to eq(Hash)
-        expect(raw_event.keys).to eq([:id, :version, :aggregate_id, :fully_qualified_name, :occurred_at, :serialized_event, :sub_key])
+        expect(raw_event.keys.to_set).to eq(Set.new([:id, :version, :aggregate_id, :fully_qualified_name, :fully_qualified_name_id, :occurred_at, :serialized_event, :sub_key]))
       end
 
       it 'should be empty for aggregates without events' do
@@ -108,14 +108,14 @@ describe EventStore::Client do
           client = es_client.new("any_device", :device)
           serialized_event = serialized_event_data_terminated_by_null
           event = EventStore::Event.new("any_device", @event_time, 'terminated_by_null_event', "zone_number", serialized_event)
-          client.append([event])
-          hex_from_db = EventStore.db.from(EventStore.fully_qualified_table).where(fully_qualified_name: 'terminated_by_null_event').first[:serialized_event]
+          retval = client.append([event])
+          hex_from_db = EventStore.db.from(EventStore.fully_qualified_table).order(:id).last[:serialized_event]
+
           expect(hex_from_db).to eql(EventStore.escape_bytea(serialized_event))
         end
       end
     end
 
-
     describe '#raw_event_streams_from_event_id' do
       subject { es_client.new(AGGREGATE_ID_ONE, :device) }
       let(:raw_stream) { subject.raw_event_stream }
@@ -243,7 +243,7 @@ describe EventStore::Client do
       let(:client) { es_client.new(AGGREGATE_ID_ONE, :device) }
 
       it 'should return the last event in the event stream' do
-        last_event = EventStore.db.from(client.event_table).where(aggregate_id: AGGREGATE_ID_ONE).order(:id).last
+        last_event = client.raw_event_stream.last
         peek = client.peek
         expect(peek.fully_qualified_name).to eq(last_event[:fully_qualified_name])
         expect(peek.event_id).to eq(last_event[:id])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Paul Saieg, John Colvin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-29 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -231,6 +231,8 @@ files:
 - db/migrations/001_create_event_store_events.rb
 - db/pg_migrations/001_create_event_store_events.rb
 - db/pg_migrations/002_create_event_store_events.rb
+- db/pg_migrations/003_add_agg_id_occurred_fqn_idx_to_event_store.rb
+- db/pg_migrations/004_add_fqn_lookup_table_to_event_store.rb
 - db/setup_db_user.sql
 - event_store.gemspec
 - lib/event_store.rb