sandthorn_driver_sequel 2.0.0 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. checksums.yaml +4 -4
  2. data/lib/sandthorn_driver_sequel/access/event_access.rb +1 -0
  3. data/lib/sandthorn_driver_sequel/event_query.rb +1 -23
  4. data/lib/sandthorn_driver_sequel/version.rb +1 -1
  5. data/sandthorn_driver_sequel.gemspec +6 -4
  6. data/spec/event_access_spec.rb +8 -2
  7. data/spec/get_events_spec.rb +22 -51
  8. data/spec/saving_events_spec.rb +13 -13
  9. data/spec/saving_snapshot_spec.rb +2 -2
  10. metadata +7 -6
  11. data/lib/sandthorn_driver_sequel/old_event_store.rb +0 -228
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 6df7059570ed2a75376a49b5568cde3dcda5abef
4
- data.tar.gz: d0df6fa0c71d2388f31897fcb4c1918ecbe6bdd2
3
+ metadata.gz: 3924bb5783466dc29b26e328fd109b286e72bed4
4
+ data.tar.gz: 464c30fdd02be1bbf86b60407aaa842a13719bae
5
5
  SHA512:
6
- metadata.gz: cff7f24db48fe2ec230c54526f3231fff0c2f7cd94ed12b585807cfa06084cba5a7c4d7d63b670816844ba8b5f6a3114a6d755bb0b16b6cb2e3336ea9c68236c
7
- data.tar.gz: 2592b3457a5c030517d968302aa4c716af3cd58fa3080c1378960a066a40fbf28000e963ab22d75c0fbf600acd3b4f75799ceea63d3a01f1c7d90d59927b5ea4
6
+ metadata.gz: 29ee3fe2c3e741503c089cae89b5fa8b6efd3680c0d58dcfb57e9a5301d80a7f191c5aee54194194321c4c41ac4230162b5976acde1de5f49998796c349b5557
7
+ data.tar.gz: 54c2d0a99c0a9258ffd08f8bc13d43f319a696e1b7a9f362d2b1b9a1fe9c6e069e94e44badf30d7d501ed1952f912eaac7424192585ba8a0b5ad243cf342c1bf
data/lib/sandthorn_driver_sequel/access/event_access.rb CHANGED
@@ -25,6 +25,7 @@ module SandthornDriverSequel
25
25
  :event_name,
26
26
  :event_data,
27
27
  :timestamp)
28
+ .order(:sequence_number)
28
29
  .all)
29
30
  end
30
31
 
data/lib/sandthorn_driver_sequel/event_query.rb CHANGED
@@ -7,19 +7,13 @@ module SandthornDriverSequel
7
7
  def build(
8
8
  aggregate_types: [],
9
9
  take: 0,
10
- after_sequence_number: 0,
11
- include_events: [],
12
- exclude_events: [])
10
+ after_sequence_number: 0)
13
11
 
14
12
  aggregate_types.map!(&:to_s)
15
- include_events.map!(&:to_s)
16
- exclude_events.map!(&:to_s)
17
13
 
18
14
  query = storage.events
19
15
  query = add_aggregate_types(query, aggregate_types)
20
16
  query = add_sequence_number(query, after_sequence_number)
21
- query = add_included_events(query, include_events)
22
- query = add_excluded_events(query, exclude_events)
23
17
  query = add_select(query)
24
18
  query = add_limit(query, take)
25
19
  @query = query.order(:sequence_number)
@@ -58,22 +52,6 @@ module SandthornDriverSequel
58
52
  ]
59
53
  end
60
54
 
61
- def add_excluded_events(query, exclude_events)
62
- if exclude_events.any?
63
- query.exclude(event_name: exclude_events)
64
- else
65
- query
66
- end
67
- end
68
-
69
- def add_included_events(query, include_events)
70
- if include_events.any?
71
- query.where(event_name: include_events)
72
- else
73
- query
74
- end
75
- end
76
-
77
55
  def add_sequence_number(query, after_sequence_number)
78
56
  query.where { sequence_number > after_sequence_number }
79
57
  end
data/lib/sandthorn_driver_sequel/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module SandthornDriverSequel
2
- VERSION = "2.0.0"
2
+ VERSION = "2.0.1"
3
3
  end
data/sandthorn_driver_sequel.gemspec CHANGED
@@ -6,13 +6,15 @@ require 'sandthorn_driver_sequel/version'
6
6
  Gem::Specification.new do |spec|
7
7
  spec.name = "sandthorn_driver_sequel"
8
8
  spec.version = SandthornDriverSequel::VERSION
9
- spec.authors = ["Lars Krantz", "Morgan Hallgren"]
10
- spec.email = ["lars.krantz@alaz.se", "morgan.hallgren@gmail.com"]
11
- spec.description = %q{sequel driver for sandthorn}
12
- spec.summary = %q{sequel driver for sandthorn}
9
+ spec.authors = ["Lars Krantz", "Morgan Hallgren", "Jesper Josefsson"]
10
+ spec.email = ["lars.krantz@alaz.se", "morgan.hallgren@gmail.com", "jesper.josefsson@gmail.com"]
11
+ spec.description = %q{Sequel driver for Sandthorn}
12
+ spec.summary = %q{Sequel driver for Sandthorn}
13
13
  spec.homepage = ""
14
14
  spec.license = "MIT"
15
15
 
16
+ spec.required_ruby_version = ">= 2.0"
17
+
16
18
  spec.files = `git ls-files`.split($/)
17
19
  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
18
20
  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
data/spec/event_access_spec.rb CHANGED
@@ -66,14 +66,20 @@ module SandthornDriverSequel
66
66
 
67
67
  describe "#find_events_by_aggregate_id" do
68
68
  context "when there are events" do
69
- it "returns correct events" do
69
+ before do
70
70
  access.store_events(aggregate, events)
71
+ end
72
+ let(:stored_events) { access.find_events_by_aggregate_id(aggregate.aggregate_id) }
71
73
 
72
- stored_events = access.find_events_by_aggregate_id(aggregate.aggregate_id)
74
+ it "returns correct events" do
73
75
  expect(stored_events.map(&:aggregate_table_id)).to all(eq(aggregate.id))
74
76
  expect(stored_events.size).to eq(events.size)
75
77
  expect(stored_events).to all(respond_to(:merge))
76
78
  end
79
+ it "returns events in correct order" do
80
+ expect(stored_events.first[:aggregate_version] < stored_events.last[:aggregate_version]).to be_truthy
81
+ expect(stored_events.first[:sequence_number] < stored_events.last[:sequence_number]).to be_truthy
82
+ end
77
83
  end
78
84
  end
79
85
 
data/spec/get_events_spec.rb CHANGED
@@ -41,75 +41,46 @@ module SandthornDriverSequel
41
41
 
42
42
  context "when using get_events" do
43
43
  context "and using take" do
44
- let(:events) {event_store.get_events after_sequence_number: 0, include_events: [:new], take: 2}
44
+ let(:events) {event_store.get_events after_sequence_number: 0, take: 2}
45
45
  it "should find 2 events" do
46
- events.length.should eql 2
47
- end
48
- end
49
- context "and getting events of type :new" do
50
- let(:events) {event_store.get_events after_sequence_number: 0, include_events: [:new]}
51
- it "should find 3 events" do
52
- events.length.should eql 3
53
- end
54
- it "should only be new-events" do
55
- events.all? { |e| e[:event_name] == "new" }
46
+ expect(events.length).to eql 2
56
47
  end
57
48
  end
58
49
  context "and combining args" do
59
50
  let(:events) do
60
51
  all = event_store.get_events after_sequence_number: 0
61
52
  first_seq_number = all[0][:sequence_number]
62
- event_store.get_events after_sequence_number: first_seq_number , exclude_events: [:foo], include_events: [:new, "bar", :flubber], take: 100
63
- end
64
- it "should find 4 events" do
65
- events.length.should eql 4
66
- end
67
- it "should not be any foo-events" do
68
- events.all? { |e| e[:event_name] != "foo" }
69
- end
70
- end
71
- context "and getting all events but excluding new" do
72
- let(:events) {event_store.get_events after_sequence_number: 0, exclude_events: [:new] }
73
- it "should find 5 events" do
74
- events.length.should eql 5
75
- end
76
- it "should only be new and foo-events" do
77
- events.all? { |e| e[:event_name] != "new" }
78
- end
79
- end
80
- context "and getting events of type :new and foo" do
81
- let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: ["String", SandthornDriverSequel::EventStore], include_events: [:new, "foo"]}
82
- it "should find 3 events" do
83
- events.length.should eql 3
53
+ event_store.get_events after_sequence_number: first_seq_number, take: 100
84
54
  end
85
- it "should only be new and foo-events" do
86
- events.all? { |e| e[:event_name] == "new" || e[:event_name] == "foo" }
55
+ it "should find 7 events" do
56
+ expect(events.length).to eql 7
87
57
  end
58
+
88
59
  end
89
60
  context "and getting events for SandthornDriverSequel::EventStore, and String after 0" do
90
61
  let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel::EventStore, String]}
91
62
  it "should find 5 events" do
92
- events.length.should eql 5
63
+ expect(events.length).to eql 5
93
64
  end
94
65
  it "should be in sequence_number order" do
95
66
  check = 0
96
- events.each { |e| e[:sequence_number].should be > check; check = e[:sequence_number] }
67
+ events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
97
68
  end
98
69
  it "should contain only events for aggregate_id_a and aggregate_id_c" do
99
- events.each { |e| [aggregate_id_a, aggregate_id_c].include?(e[:aggregate_id]).should be_truthy }
70
+ events.each { |e| expect([aggregate_id_a, aggregate_id_c].include?(e[:aggregate_id])).to be_truthy }
100
71
  end
101
72
  end
102
73
  context "and getting events for SandthornDriverSequel::EventStore after 0" do
103
74
  let(:events) {event_store.get_events after_sequence_number: 0, aggregate_types: [SandthornDriverSequel::EventStore]}
104
75
  it "should find 3 events" do
105
- events.length.should eql 3
76
+ expect(events.length).to eql 3
106
77
  end
107
78
  it "should be in sequence_number order" do
108
79
  check = 0
109
- events.each { |e| e[:sequence_number].should be > check; check = e[:sequence_number] }
80
+ events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
110
81
  end
111
82
  it "should contain only events for aggregate_id_a" do
112
- events.each { |e| e[:aggregate_id].should eql aggregate_id_a }
83
+ events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a }
113
84
  end
114
85
  end
115
86
  end
@@ -117,38 +88,38 @@ module SandthornDriverSequel
117
88
  context "and getting events for SandthornDriverSequel::EventStore after 0" do
118
89
  let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore}
119
90
  it "should find 3 events" do
120
- events.length.should eql 3
91
+ expect(events.length).to eql 3
121
92
  end
122
93
  it "should be in sequence_number order" do
123
94
  check = 0
124
- events.each { |e| e[:sequence_number].should be > check; check = e[:sequence_number] }
95
+ events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
125
96
  end
126
97
  it "should contain only events for aggregate_id_a" do
127
- events.each { |e| e[:aggregate_id].should eql aggregate_id_a }
98
+ events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_a }
128
99
  end
129
100
  it "should be able to get events after a sequence number" do
130
101
  new_from = events[1][:sequence_number]
131
102
  ev = event_store.get_new_events_after_event_id_matching_classname new_from, SandthornDriverSequel::EventStore
132
- ev.last[:aggregate_version].should eql 3
133
- ev.length.should eql 1
103
+ expect(ev.last[:aggregate_version]).to eql 3
104
+ expect(ev.length).to eql 1
134
105
  end
135
106
  it "should be able to limit the number of results" do
136
107
  ev = event_store.get_new_events_after_event_id_matching_classname 0, SandthornDriverSequel::EventStore, take: 2
137
- ev.length.should eql 2
138
- ev.last[:aggregate_version].should eql 2
108
+ expect(ev.length).to eql 2
109
+ expect(ev.last[:aggregate_version]).to eql 2
139
110
  end
140
111
  end
141
112
  context "and getting events for String after 0" do
142
113
  let(:events) {event_store.get_new_events_after_event_id_matching_classname 0, "String"}
143
114
  it "should find 3 events" do
144
- events.length.should eql 2
115
+ expect(events.length).to eql 2
145
116
  end
146
117
  it "should be in sequence_number order" do
147
118
  check = 0
148
- events.each { |e| e[:sequence_number].should be > check; check = e[:sequence_number] }
119
+ events.each { |e| expect(e[:sequence_number]).to be > check; check = e[:sequence_number] }
149
120
  end
150
121
  it "should contain only events for aggregate_id_c" do
151
- events.each { |e| e[:aggregate_id].should eql aggregate_id_c }
122
+ events.each { |e| expect(e[:aggregate_id]).to eql aggregate_id_c }
152
123
  end
153
124
  end
154
125
  end
data/spec/saving_events_spec.rb CHANGED
@@ -17,19 +17,19 @@ module SandthornDriverSequel
17
17
  it "should be able to save and retrieve events on the aggregate" do
18
18
  event_store.save_events test_events, aggregate_id, String
19
19
  events = event_store.get_aggregate_events aggregate_id
20
- events.length.should eql test_events.length
20
+ expect(events.length).to eql test_events.length
21
21
  end
22
22
 
23
23
  it "should have correct keys when asking for events" do
24
24
  event_store.save_events test_events, aggregate_id, String
25
25
  events = event_store.get_aggregate aggregate_id, String
26
26
  event = events.first
27
- event[:event_data].should eql(test_events.first[:event_data])
28
- event[:event_name].should eql("new")
29
- event[:aggregate_id].should eql aggregate_id
30
- event[:aggregate_version].should eql 1
31
- event[:sequence_number].should be_a(Fixnum)
32
- event[:timestamp].should be_a(Time)
27
+ expect(event[:event_data]).to eql(test_events.first[:event_data])
28
+ expect(event[:event_name]).to eql("new")
29
+ expect(event[:aggregate_id]).to eql aggregate_id
30
+ expect(event[:aggregate_version]).to eql 1
31
+ expect(event[:sequence_number]).to be_a(Fixnum)
32
+ expect(event[:timestamp]).to be_a(Time)
33
33
  end
34
34
  end
35
35
 
@@ -56,16 +56,16 @@ module SandthornDriverSequel
56
56
 
57
57
  it "both types should exist in get_all_typenames in alphabetical order" do
58
58
  names = event_store.get_all_types
59
- names.length.should eql 2
60
- names.first.should eql "Hash"
61
- names.last.should eql "String"
59
+ expect(names.length).to eql 2
60
+ expect(names.first).to eql "Hash"
61
+ expect(names.last).to eql "String"
62
62
  end
63
63
 
64
64
  it "should list the aggregate ids when asking for get_aggregate_list_by_typename" do
65
65
  ids = event_store.get_aggregate_ids(aggregate_type: String)
66
- ids.length.should eql 2
67
- ids.any? { |e| e == aggregate_id_1 }.should be_truthy
68
- ids.any? { |e| e == aggregate_id_3 }.should be_truthy
66
+ expect(ids.length).to eql 2
67
+ expect(ids.any? { |e| e == aggregate_id_1 }).to be_truthy
68
+ expect(ids.any? { |e| e == aggregate_id_3 }).to be_truthy
69
69
  end
70
70
  end
71
71
 
data/spec/saving_snapshot_spec.rb CHANGED
@@ -40,7 +40,7 @@ module SandthornDriverSequel
40
40
  it "should be able to save and get snapshot" do
41
41
  save_snapshot
42
42
  snap = event_store.get_snapshot(aggregate_id)
43
- snap.should eql snapshot_data
43
+ expect(snap).to eql snapshot_data
44
44
  end
45
45
  end
46
46
  context "when trying to save a snapshot on a non-existing aggregate" do
@@ -69,7 +69,7 @@ module SandthornDriverSequel
69
69
  data[:aggregate_version] = 1
70
70
  event_store.save_snapshot(data, aggregate_id)
71
71
  snap = event_store.get_snapshot(aggregate_id)
72
- snap.should eql data
72
+ expect(snap).to eql data
73
73
  end
74
74
  end
75
75
  end
metadata CHANGED
@@ -1,15 +1,16 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: sandthorn_driver_sequel
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.0.0
4
+ version: 2.0.1
5
5
  platform: ruby
6
6
  authors:
7
7
  - Lars Krantz
8
8
  - Morgan Hallgren
9
+ - Jesper Josefsson
9
10
  autorequire:
10
11
  bindir: bin
11
12
  cert_chain: []
12
- date: 2015-03-09 00:00:00.000000000 Z
13
+ date: 2015-04-01 00:00:00.000000000 Z
13
14
  dependencies:
14
15
  - !ruby/object:Gem::Dependency
15
16
  name: bundler
@@ -235,10 +236,11 @@ dependencies:
235
236
  - - ">="
236
237
  - !ruby/object:Gem::Version
237
238
  version: '0'
238
- description: sequel driver for sandthorn
239
+ description: Sequel driver for Sandthorn
239
240
  email:
240
241
  - lars.krantz@alaz.se
241
242
  - morgan.hallgren@gmail.com
243
+ - jesper.josefsson@gmail.com
242
244
  executables: []
243
245
  extensions: []
244
246
  extra_rdoc_files: []
@@ -264,7 +266,6 @@ files:
264
266
  - lib/sandthorn_driver_sequel/event_store.rb
265
267
  - lib/sandthorn_driver_sequel/event_store_context.rb
266
268
  - lib/sandthorn_driver_sequel/migration.rb
267
- - lib/sandthorn_driver_sequel/old_event_store.rb
268
269
  - lib/sandthorn_driver_sequel/sequel_driver.rb
269
270
  - lib/sandthorn_driver_sequel/storage.rb
270
271
  - lib/sandthorn_driver_sequel/utilities.rb
@@ -300,7 +301,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
300
301
  requirements:
301
302
  - - ">="
302
303
  - !ruby/object:Gem::Version
303
- version: '0'
304
+ version: '2.0'
304
305
  required_rubygems_version: !ruby/object:Gem::Requirement
305
306
  requirements:
306
307
  - - ">="
@@ -311,7 +312,7 @@ rubyforge_project:
311
312
  rubygems_version: 2.4.3
312
313
  signing_key:
313
314
  specification_version: 4
314
- summary: sequel driver for sandthorn
315
+ summary: Sequel driver for Sandthorn
315
316
  test_files:
316
317
  - spec/aggregate_access_spec.rb
317
318
  - spec/asking_for_aggregates_to_snapshot_spec.rb
data/lib/sandthorn_driver_sequel/old_event_store.rb DELETED
@@ -1,228 +0,0 @@
1
- require 'sandthorn_driver_sequel/sequel_driver'
2
-
3
- module SandthornDriverSequel
4
- class OldEventStore
5
- include EventStoreContext
6
- attr_reader :driver, :context, :url
7
- def initialize url: nil, context: nil
8
- @driver = SequelDriver.new url: url
9
- @context = context
10
- @url = url
11
- end
12
-
13
- def save_events aggregate_events, originating_aggregate_version, aggregate_id, class_name
14
- current_aggregate_version = originating_aggregate_version
15
- aggregate_type = class_name.to_s
16
- driver.execute_in_transaction do |db|
17
- if current_aggregate_version == 0
18
- pk_id = register_new_aggregate(aggregate_id, aggregate_type, db)
19
- else
20
- current_aggregate = get_current_aggregate_from_aggregates_table(aggregate_id, aggregate_type, db)
21
- check_initial_aggregate_version!(current_aggregate, current_aggregate_version)
22
- pk_id = current_aggregate[:id]
23
- end
24
- timestamp = Time.now.utc
25
- aggregate_events.each do |event|
26
- current_aggregate_version += 1
27
- check_event_aggregate_version!(event, class_name, current_aggregate_version)
28
- insert_event(db, event, pk_id, timestamp)
29
- end
30
- db[aggregates_table_name].where(id: pk_id).update(aggregate_version: current_aggregate_version)
31
- end
32
- end
33
-
34
- def insert_event(db, event, pk_id, timestamp)
35
- to_insert = {
36
- aggregate_table_id: pk_id,
37
- aggregate_version: event[:aggregate_version],
38
- event_name: event[:event_name],
39
- event_data: event[:event_data],
40
- timestamp: timestamp
41
- }
42
- db[events_table_name].insert(to_insert)
43
- end
44
-
45
- def check_event_aggregate_version!(event, aggregate_type, current_aggregate_version)
46
- if event[:aggregate_version] != current_aggregate_version
47
- raise SandthornDriverSequel::Errors::ConcurrencyError, event, aggregate_type, current_aggregate_version
48
- end
49
- end
50
-
51
- def check_initial_aggregate_version!(aggregate, current_aggregate_version)
52
- if aggregate[:aggregate_version] != current_aggregate_version
53
- raise SandthornDriverSequel::Errors::WrongAggregateVersionError, aggregate, current_aggregate_version
54
- end
55
- end
56
-
57
- def register_new_aggregate(aggregate_id, aggregate_type, db)
58
- to_insert = {
59
- aggregate_id: aggregate_id,
60
- aggregate_type: aggregate_type,
61
- aggregate_version: 0
62
- }
63
- pk_id = db[aggregates_table_name].insert(to_insert)
64
- end
65
-
66
- def save_snapshot aggregate_snapshot, aggregate_id, class_name
67
- driver.execute_in_transaction do |db|
68
- current_aggregate = get_current_aggregate_from_aggregates_table aggregate_id, class_name, db
69
- pk_id = current_aggregate[:id]
70
- current_snapshot = get_current_snapshot pk_id, db
71
- aggregate_version = aggregate_snapshot[:aggregate_version]
72
- return if snapshot_fresh?(current_snapshot, aggregate_version)
73
- check_snapshot_version!(current_aggregate, aggregate_version)
74
- if current_snapshot.nil?
75
- to_insert = {aggregate_version: aggregate_version, snapshot_data: aggregate_snapshot[:event_data], aggregate_table_id: pk_id }
76
- db[snapshots_table_name].insert(to_insert)
77
- else
78
- to_update = {aggregate_version: aggregate_version, snapshot_data: aggregate_snapshot[:event_data] }
79
- db[snapshots_table_name].where(aggregate_table_id: pk_id).update(to_update)
80
- end
81
- end
82
- end
83
-
84
- def snapshot_fresh?(current_snapshot, aggregate_version)
85
- !current_snapshot.nil? && current_snapshot[:aggregate_version] == aggregate_version
86
- end
87
-
88
- def check_snapshot_version!(aggregate, aggregate_version)
89
- if aggregate[:aggregate_version] < aggregate_version
90
- raise SandthornDriverSequel::Errors::WrongSnapshotVersionError, aggregate, version
91
- end
92
- end
93
-
94
- def get_aggregate_events aggregate_id, *class_name
95
- #aggregate_type = class_name.to_s unless class_name.nil?
96
- return aggregate_events aggregate_id: aggregate_id
97
- end
98
-
99
- def get_aggregate aggregate_id, *class_name
100
- snapshot = get_snapshot aggregate_id, class_name
101
- after_aggregate_version = 0
102
- after_aggregate_version = snapshot[:aggregate_version] unless snapshot.nil?
103
- events = aggregate_events after_aggregate_version: after_aggregate_version, aggregate_id: aggregate_id
104
- unless snapshot.nil?
105
- snap_event = snapshot
106
- snap_event[:event_name] = "aggregate_set_from_snapshot"
107
- events = events.unshift(snap_event)
108
- end
109
- events
110
- end
111
- def get_aggregate_list_by_typename class_name
112
- aggregate_type = class_name.to_s
113
- driver.execute do |db|
114
- db[aggregates_table_name].where(aggregate_type: aggregate_type).select(:aggregate_id).map { |e| e[:aggregate_id] }
115
- end
116
- end
117
-
118
- def get_all_typenames
119
- driver.execute do |db|
120
- db[aggregates_table_name].select(:aggregate_type).distinct.order(:aggregate_type).map{|e| e[:aggregate_type]}
121
- end
122
- end
123
-
124
- def get_snapshot aggregate_id, *class_name
125
- aggregate_type = class_name.first.to_s
126
- driver.execute do |db|
127
- current_aggregate = get_current_aggregate_from_aggregates_table aggregate_id, aggregate_type, db
128
- snap = get_current_snapshot current_aggregate[:id], db
129
- return nil if snap.nil?
130
- return {aggregate_version: snap[:aggregate_version], event_data: snap[:snapshot_data]}
131
- end
132
- end
133
-
134
- def get_new_events_after_event_id_matching_classname event_id, class_name, args = {}
135
- take = args.fetch(:take, 0)
136
- aggregate_type = class_name.to_s
137
- driver.execute do |db|
138
- query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_type: aggregate_type)
139
- query = query.where{sequence_number > event_id}
140
- rel = "#{events_table_name}__aggregate_version".to_sym
141
- query = query.select(:aggregate_type, rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp)
142
- query = query.limit(take) if take > 0
143
- return query.order(:sequence_number).all
144
- end
145
- end
146
- def get_events aggregate_types: [], take: 0, after_sequence_number: 0, include_events: [], exclude_events: []
147
- include_events = include_events.map { |e| e.to_s }
148
- exclude_events = exclude_events.map { |e| e.to_s }
149
- aggregate_types = aggregate_types.map { |e| e.to_s }
150
- driver.execute do |db|
151
- if aggregate_types.empty?
152
- query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id)
153
- else
154
- query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_type: aggregate_types)
155
- end
156
- query = query.where{sequence_number > after_sequence_number}
157
- unless include_events.empty?
158
- query = query.where(event_name: include_events)
159
- end
160
- unless exclude_events.empty?
161
- query = query.exclude(event_name: exclude_events)
162
- end
163
- rel = "#{events_table_name}__aggregate_version".to_sym
164
- query = query.select(:aggregate_type, rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp)
165
- query = query.limit(take) if take > 0
166
- return query.order(:sequence_number).all
167
- end
168
- end
169
- def obsolete_snapshots aggregate_types: [], max_event_distance: 100
170
- driver.execute do |db|
171
- rel = "#{snapshots_table_name}__aggregate_version".to_sym
172
- aggr_rel = "#{aggregates_table_name}__aggregate_version".to_sym
173
- query_select = eval("lambda{(#{aggr_rel} - coalesce(#{rel},0)).as(distance)}")
174
- query = db[aggregates_table_name].left_outer_join(snapshots_table_name, aggregate_table_id: :id)
175
- query = query.select &query_select
176
- query = query.select_append(:aggregate_id, :aggregate_type)
177
- query_where = eval("lambda{(#{aggr_rel} - coalesce(#{rel},0)) > max_event_distance}")
178
- query = query.where &query_where
179
- unless class_names.empty?
180
- class_names.map! {|c|c.to_s}
181
- query = query.where(aggregate_type: class_names)
182
- end
183
- query.all
184
- end
185
- end
186
- private
187
-
188
- def aggregate_events after_aggregate_version: 0, aggregate_id: nil
189
-
190
- rel = "#{events_table_name}__aggregate_version".to_sym
191
- where_proc = eval("lambda{ #{rel} > after_aggregate_version }")
192
- driver.execute do |db|
193
- query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_id: aggregate_id)
194
- query = query.where &where_proc
195
- result = query.select(rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp).order(:sequence_number).all
196
- end
197
-
198
- # result = nil
199
- # Benchmark.bm do |x|
200
- # x.report("find") {
201
- # rel = "#{events_table_name}__aggregate_version".to_sym
202
- # where_proc = eval("lambda{ #{rel} > after_aggregate_version }")
203
- # driver.execute do |db|
204
- # query = db[events_table_name].join(aggregates_table_name, id: :aggregate_table_id, aggregate_id: aggregate_id)
205
- # query = query.where &where_proc
206
- # result = query.select(rel, :aggregate_id, :sequence_number, :event_name, :event_data, :timestamp).order(:sequence_number).all
207
- # end
208
- # }
209
-
210
- # end
211
- # result
212
- end
213
- def get_current_aggregate_from_aggregates_table aggregate_id, aggregate_type, db
214
- aggregate_type = aggregate_type.to_s
215
- current_aggregate = db[aggregates_table_name].where(aggregate_id: aggregate_id)
216
- if current_aggregate.empty?
217
- error_message = "#{aggregate_type} with id #{aggregate_id} was not found in the eventstore."
218
- raise SandthornDriverSequel::Errors::NoAggregateError.new(error_message)
219
- end
220
- current_aggregate.first
221
- end
222
- def get_current_snapshot aggregate_table_id, db
223
- snap = db[snapshots_table_name].where(aggregate_table_id: aggregate_table_id)
224
- return nil if snap.empty?
225
- snap.first
226
- end
227
- end
228
- end