pg_eventstore 0.8.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be890a0bd9b5ffdf7289b76b503cdb659157a3dfe387d906e96cb7d57fbb8e63
-  data.tar.gz: 182a72941b0d9a2d242e6e3cf6cebe623b992905912e42f3877af5f9d8acdd96
+  metadata.gz: 9426880dd6354875d896f5bf37abeac180c4f04b26905db0efc035fec316e6b9
+  data.tar.gz: 355a6c370451fff9e391aa0ecb1c6abf105c6fc537d99f6b7371359067dd2ee4
 SHA512:
-  metadata.gz: ea65eb0d4ffc1287c95eaeb7e8e795701a692dd30d82356cbd10b4ca8217fd59f658dca7e758a5b63f6eb5e1ff69913d6bebc2f48c4449e12386dd483598a532
-  data.tar.gz: ff5184dd724271d1276986c8d639011182a857cf65f08fe293b9f030ee14df9b18b4dfae81ab8676191e1c124b4a1f30f61ff26f892a6008ec6af6c95203df6c
+  metadata.gz: fc96e847b892e375115a08985678328d166742e5f6be3ee967f67dc808c80166a58f010555567b05fbac172b31c7d98276d1e898de6889d5d53d3ccf0ab2be47
+  data.tar.gz: cba82b0c20d4104cd6878fd2471e5c4d0c70e60991f573cd5aa1a845e7e5b443cf9f15448b81754888a84883c6bfbaf932e452c13fd7d5d229b03185741f1dbd

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.10.1] - 2024-03-12
+
+- Handle edge case when creating partitions
+
+## [0.10.0] - 2024-03-12
+
+- Reimplement db structure
+- Optimize `#append_to_stream` method - it now produces one `INSERT` query when publishing multiple events
+
+## [0.9.0] - 2024-02-23
+
+- Use POSIX locale for streams and event types
+
 ## [0.8.0] - 2024-02-20
 
 - Allow float values for `subscription_pull_interval`. The default value of it was also set to `1.0`(it was `2` previously)

data/db/migrations/{3_create_events.sql → 1_create_events.sql}

@@ -1,27 +1,24 @@
 CREATE TABLE public.events
 (
     id              uuid                        DEFAULT public.gen_random_uuid() NOT NULL,
-    stream_id       bigint                                                       NOT NULL,
+    context         character varying COLLATE "POSIX"                            NOT NULL,
+    stream_name     character varying COLLATE "POSIX"                            NOT NULL,
+    stream_id       character varying COLLATE "POSIX"                            NOT NULL,
     global_position bigserial                                                    NOT NULL,
     stream_revision integer                                                      NOT NULL,
     data            jsonb                       DEFAULT '{}'::jsonb              NOT NULL,
     metadata        jsonb                       DEFAULT '{}'::jsonb              NOT NULL,
     link_id         uuid,
     created_at      timestamp without time zone DEFAULT now()                    NOT NULL,
-    event_type_id   bigint                                                       NOT NULL
-);
+    type            character varying COLLATE "POSIX"                            NOT NULL
+) PARTITION BY LIST (context);
 
 ALTER TABLE ONLY public.events
-    ADD CONSTRAINT events_pkey PRIMARY KEY (id);
+    ADD CONSTRAINT events_pkey PRIMARY KEY (context, stream_name, type, global_position);
 
-CREATE INDEX idx_events_event_type_id_and_global_position ON public.events USING btree (event_type_id, global_position);
-CREATE INDEX idx_events_global_position ON public.events USING btree (global_position);
-CREATE INDEX idx_events_link_id ON public.events USING btree (link_id);
-CREATE INDEX idx_events_stream_id_and_revision ON public.events USING btree (stream_id, stream_revision);
+CREATE INDEX idx_events_stream_id_and_stream_revision ON public.events USING btree (stream_id, stream_revision);
+CREATE INDEX idx_events_stream_id_and_global_position ON public.events USING btree (stream_id, global_position);
 
-ALTER TABLE ONLY public.events
-    ADD CONSTRAINT events_stream_fk FOREIGN KEY (stream_id) REFERENCES public.streams (id) ON DELETE CASCADE;
-ALTER TABLE ONLY public.events
-    ADD CONSTRAINT events_event_type_fk FOREIGN KEY (event_type_id) REFERENCES public.event_types (id);
-ALTER TABLE ONLY public.events
-    ADD CONSTRAINT events_link_fk FOREIGN KEY (link_id) REFERENCES public.events (id) ON DELETE CASCADE;
+CREATE INDEX idx_events_id ON public.events USING btree (id);
+CREATE INDEX idx_events_link_id ON public.events USING btree (link_id);
+CREATE INDEX idx_events_global_position ON public.events USING btree (global_position);

data/db/migrations/{4_create_subscriptions.sql → 2_create_subscriptions.sql}

@@ -32,7 +32,7 @@ CREATE TABLE public.subscriptions
     last_restarted_at             timestamp without time zone,
     last_error                    jsonb,
     last_error_occurred_at        timestamp without time zone,
-    chunk_query_interval          int2                        NOT NULL DEFAULT 5,
+    chunk_query_interval          float4                      NOT NULL DEFAULT 1.0,
     last_chunk_fed_at             timestamp without time zone NOT NULL DEFAULT to_timestamp(0),
     last_chunk_greatest_position  bigint,
     locked_by                     uuid,

data/db/migrations/5_partitions.sql

@@ -0,0 +1,16 @@
+CREATE TABLE public.partitions
+(
+    id          bigserial                         NOT NULL,
+    context     character varying COLLATE "POSIX" NOT NULL,
+    stream_name character varying COLLATE "POSIX",
+    event_type  character varying COLLATE "POSIX",
+    table_name  character varying COLLATE "POSIX" NOT NULL
+);
+
+ALTER TABLE ONLY public.partitions
+    ADD CONSTRAINT partitions_pkey PRIMARY KEY (id);
+
+CREATE UNIQUE INDEX idx_partitions_by_context ON public.partitions USING btree (context) WHERE stream_name IS NULL AND event_type IS NULL;
+CREATE UNIQUE INDEX idx_partitions_by_context_and_stream_name ON public.partitions USING btree (context, stream_name) WHERE event_type IS NULL;
+CREATE UNIQUE INDEX idx_partitions_by_context_and_stream_name_and_event_type ON public.partitions USING btree (context, stream_name, event_type);
+CREATE UNIQUE INDEX idx_partitions_by_partition_table_name ON public.partitions USING btree (table_name);

data/docs/events_and_streams.md

@@ -22,7 +22,7 @@
 Example:
 
 ```ruby
-PgEventstore::Event.new(data: { 'foo' => 'bar' })
+PgEventstore::Event.new(data: { 'foo' => 'bar' }, type: 'FooChanged')
 ```
 
 ## Stream object
@@ -32,8 +32,6 @@ To be able to manipulate a stream, you have to compute a stream's object first.
 - `context` - String(required). A Bounded Context, read more [here](https://martinfowler.com/bliki/BoundedContext.html). Values which start from `$` sign are reserved by `pg_eventstore`. Such contexts can't be used to append events.
 - `stream_name` - String(required). A stream name.
 - `stream_id` - String(required). A stream id.
-- `id` - Integer(optional, read only). Internal id. It is set when a stream is returned from the database as part of the deserialization process. Manually assigning this attribute has no effect.
-- `stream_revision` - Integer(optional, read only). Current stream's revision. You can rely on this value when setting the `:expected_revision` option when appending events to a stream. It is set when a stream is returned from the database a part of the deserialization process. Manually assigning this attribute has no effect.
 
 Example:
 
@@ -43,3 +41,7 @@ PgEventstore::Stream.new(context: 'Sales', stream_name: 'Customer', stream_id: '
 ```
 
 There is a special stream, called the "all" stream. You can get this object by calling the`PgEventstore::Stream.all_stream` method. Read more about the "all" stream in the `Reading from the "all" stream` section of [Reading events](reading_events.md) chapter.
+
+## Important note
+
+Because the database is designed for Eventsourcing, some limitations should be met - a combination of `Event#type`, `Stream#context` and `Stream#stream_name` must have low cardinality(low unique values number). This means you should pre-defined values there. Otherwise it may lead to the performance degradation. See [How it works](how_it_works.md) chapter for the details.

data/docs/how_it_works.md

@@ -0,0 +1,80 @@
+# How it works
+
+## Database architecture
+
+The database is designed specifically for Eventsourcing using Domain-Driven Design. `events` table is partitioned in next way:
+
+- For each `Stream#context` there is a subpartition of `events` table. Those tables have `contexts_` prefix.
+- For each `Stream#stream_name` there is a subpartition of `contexts_` table. Those tables have `stream_names_` prefix.
+- For each `Event#type` there is a subpartition of `stream_names_` table. Those tables have `event_types_` prefix.
+
+To implement partitions - Declarative Partitioning is used. Partitioning means that you should not have any random values in the combination of `Stream#context`, `Stream#stream_name` and `Event#type`. A combination of those values must have low cardinality(low distinct values number) and must be pre-defined in your application. Otherwise it will lead to the performance degradation. More about PostgreSQL partitions is [here](https://www.postgresql.org/docs/current/ddl-partitioning.html),
+
+So, let's say you want to publish next event:
+
+```ruby
+stream = PgEventstore::Stream.new(context: 'SomeCtx', stream_name: 'SomeStream', stream_id: '1')
+event = PgEventstore::Event.new(type: 'SomethingChanged', data: { foo: :bar })
+PgEventstore.client.append_to_stream(stream, event)
+```
+
+To actually create `events` record next partitions will be created:
+
+- `contexts_81820a` table which is a subpartition of `events` table. It is needed to handle all events which comes to `"SomeCtx"` context
+- `stream_names_ecb803` table which is a subpartition of `contexts_81820a` table. It is needed to handle all events which comes to `"SomeStream"` stream name of `"SomeCtx"` context
+- `event_types_aeadd5` table which is a subpartition of `stream_names_ecb803` table. It is needed to handle all events which have `"SomethingChanged"` event type of `"SomeStream"` stream name of `"SomeCtx"` context
+
+You can check all partitions and associated with them contexts, stream names and event types by querying `partitions` table. Example(based on the publish sample above):
+
+```ruby
+PgEventstore.connection.with do |conn|
+  conn.exec('select * from partitions')
+end.to_a
+# =>
+#   [{"id"=>1, "context"=>"SomeCtx", "stream_name"=>nil, "event_type"=>nil, "table_name"=>"contexts_81820a"},
+#    {"id"=>2, "context"=>"SomeCtx", "stream_name"=>"SomeStream", "event_type"=>nil, "table_name"=>"stream_names_ecb803"},
+#    {"id"=>3, "context"=>"SomeCtx", "stream_name"=>"SomeStream", "event_type"=>"SomethingChanged", "table_name"=>"event_types_aeadd5"}]
+```
+
+## Appending events and multiple commands
+
+You may want to get familiar with [Appending events](appending_events.md) and [multiple commands](multiple_commands.md) first.
+
+`pg_eventstore` internally uses `Serializable` transaction isolation level(more about different transaction isolation levels in PostgreSQL is [here](https://www.postgresql.org/docs/current/transaction-iso.html)). On practice this means that any transaction may fail with serialization error, and the common approach is to restart this transaction. For ruby this means re-execution of the block of code. Which is why there is a warning regarding potential block re-execution when using `#multiple`. However current implementation allows to limit 99% of retries to the manipulations with one stream. For example, when two parallel processes changing the same stream. If different streams are being changed at the same time - it is less likely it would perform retry.
+
+Examples:
+
+- if "process 1" and "process 2" perform the append command at the same time - one of the append commands will be retried:
+```ruby
+# process 1
+stream = PgEventstore::Stream.new(context: 'MyCtx', stream_name: 'MyStream', stream_id: '1')
+event = PgEventstore::Event.new(type: 'SomethingChanged', data: { foo: :bar })
+PgEventstore.client.append_to_stream(stream, event)
+
+# process 2
+stream = PgEventstore::Stream.new(context: 'MyCtx', stream_name: 'MyStream', stream_id: '1')
+event = PgEventstore::Event.new(type: 'SomethingElseChanged', data: { baz: :bar })
+PgEventstore.client.append_to_stream(stream, event)
+```
+
+- if "process 1" performs multiple commands at the same time "process 2" performs append command which involves the same stream from "process 1" - either block of `#multiple` or `#append_to_stream` will be retried:
+
+```ruby
+# process 1
+stream1 = PgEventstore::Stream.new(context: 'MyCtx', stream_name: 'MyStream1', stream_id: '1')
+stream2 = PgEventstore::Stream.new(context: 'MyCtx', stream_name: 'MyStream2', stream_id: '1')
+event = PgEventstore::Event.new(type: 'SomethingChanged', data: { foo: :bar })
+PgEventstore.client.multiple do
+  PgEventstore.client.append_to_stream(stream1, event)
+  PgEventstore.client.append_to_stream(stream2, event)
+end
+
+# process 2
+stream2 = PgEventstore::Stream.new(context: 'MyCtx', stream_name: 'MyStream2', stream_id: '1')
+event = PgEventstore::Event.new(type: 'SomethingChanged', data: { foo: :bar })
+PgEventstore.client.append_to_stream(stream2, event)
+```
+
+Retries also concern your potential implementation of [middlewares](writing_middleware.md). For example, `YourAwesomeMiddleware#serialize` can be executed several times when append the event. This is especially important when you involve your microservices here - they can receive the same payload several times.
+
+Conclusion. When developing using `pg_eventstore` - always keep in mind that some parts of your implementation can be executed several times before successfully publishing an event, or event when reading events(`#deserializa` middleware method) if you perform reading withing `#multiple` block. 

data/lib/pg_eventstore/client.rb

@@ -29,7 +29,9 @@ module PgEventstore
       result =
         Commands::Append.new(
           Queries.new(
-            streams: stream_queries, events: event_queries(middlewares(middlewares)), transactions: transaction_queries
+            partitions: partition_queries,
+            events: event_queries(middlewares(middlewares)),
+            transactions: transaction_queries
           )
         ).call(stream, *events_or_event, options: options)
       events_or_event.is_a?(Array) ? result : result.first
@@ -105,7 +107,7 @@ module PgEventstore
     # @raise [PgEventstore::StreamNotFoundError]
     def read(stream, options: {}, middlewares: nil)
       Commands::Read.
-        new(Queries.new(streams: stream_queries, events: event_queries(middlewares(middlewares)))).
+        new(Queries.new(partitions: partition_queries, events: event_queries(middlewares(middlewares)))).
         call(stream, options: { max_count: config.max_count }.merge(options))
     end
 
@@ -114,7 +116,7 @@ module PgEventstore
     def read_paginated(stream, options: {}, middlewares: nil)
       cmd_class = stream.system? ? Commands::SystemStreamReadPaginated : Commands::RegularStreamReadPaginated
       cmd_class.
-        new(Queries.new(streams: stream_queries, events: event_queries(middlewares(middlewares)))).
+        new(Queries.new(partitions: partition_queries, events: event_queries(middlewares(middlewares)))).
         call(stream, options: { max_count: config.max_count }.merge(options))
     end
 
@@ -133,7 +135,9 @@ module PgEventstore
       result =
         Commands::LinkTo.new(
           Queries.new(
-            streams: stream_queries, events: event_queries(middlewares(middlewares)), transactions: transaction_queries
+            partitions: partition_queries,
+            events: event_queries(middlewares(middlewares)),
+            transactions: transaction_queries
           )
         ).call(stream, *events_or_event, options: options)
       events_or_event.is_a?(Array) ? result : result.first
@@ -154,9 +158,9 @@ module PgEventstore
       PgEventstore.connection(config.name)
     end
 
-    # @return [PgEventstore::StreamQueries]
-    def stream_queries
-      StreamQueries.new(connection)
+    # @return [PgEventstore::PartitionQueries]
+    def partition_queries
+      PartitionQueries.new(connection)
     end
 
     # @return [PgEventstore::TransactionQueries]

data/lib/pg_eventstore/commands/append.rb

@@ -16,19 +16,28 @@ module PgEventstore
         raise SystemStreamError, stream if stream.system?
 
         queries.transactions.transaction do
-          stream = queries.streams.find_or_create_stream(stream)
-          revision = stream.stream_revision
+          revision = queries.events.stream_revision(stream) || Stream::NON_EXISTING_STREAM_REVISION
           assert_expected_revision!(revision, options[:expected_revision], stream) if options[:expected_revision]
-          events.map.with_index(1) do |event, index|
-            queries.events.insert(stream, event_modifier.call(event, revision + index))
-          end.tap do
-            queries.streams.update_stream_revision(stream, revision + events.size)
+          formatted_events = events.map.with_index(1) do |event, index|
+            event_modifier.call(event, revision + index)
           end
+          create_partitions(stream, formatted_events)
+          queries.events.insert(stream, formatted_events)
         end
       end
 
       private
 
+      # @param stream [PgEventstore::Stream]
+      # @param events [Array<PgEventstore::Event>]
+      # @return [void]
+      def create_partitions(stream, events)
+        missing_event_types = events.map(&:type).map(&:to_s).uniq.select do |event_type|
+          queries.partitions.partition_required?(stream, event_type)
+        end
+        raise MissingPartitions.new(stream, missing_event_types) if missing_event_types.any?
+      end
+
       # @param revision [Integer]
       # @param expected_revision [Symbol, Integer]
       # @param stream [PgEventstore::Stream]
@@ -46,12 +55,12 @@ module PgEventstore
           end
 
         in [Integer, Symbol]
-          if revision == Stream::INITIAL_STREAM_REVISION && expected_revision == :stream_exists
+          if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :stream_exists
             raise WrongExpectedRevisionError.new(
               revision: revision, expected_revision: expected_revision, stream: stream
             )
           end
-          if revision > Stream::INITIAL_STREAM_REVISION && expected_revision == :no_stream
+          if revision > Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :no_stream
             raise WrongExpectedRevisionError.new(
               revision: revision, expected_revision: expected_revision, stream: stream
             )

data/lib/pg_eventstore/commands/link_to.rb

@@ -13,7 +13,7 @@ module PgEventstore
       # @raise [PgEventstore::WrongExpectedRevisionError]
       # @raise [PgEventstore::NotPersistedEventError]
       def call(stream, *events, options: {})
-        events.each(&method(:check_id_presence))
+        events.each(&method(:check_event_presence))
         append_cmd = Append.new(queries)
         append_cmd.call(stream, *events, options: options, event_modifier: EventModifiers::PrepareLinkEvent)
       end
@@ -23,8 +23,8 @@ module PgEventstore
       # Checks if Event#id is present. An event must have the #id value in order to be linked.
       # @param event [PgEventstore::Event]
       # @return [void]
-      def check_id_presence(event)
-        return unless event.id.nil?
+      def check_event_presence(event)
+        return if queries.events.event_exists?(event.id)
 
         raise NotPersistedEventError, event
       end

data/lib/pg_eventstore/commands/read.rb

@@ -15,7 +15,7 @@ module PgEventstore
       # @return [Array<PgEventstore::Event>]
       # @raise [PgEventstore::StreamNotFoundError]
       def call(stream, options: {})
-        stream = queries.streams.find_stream(stream) || raise(StreamNotFoundError, stream) unless stream.all_stream?
+        queries.events.stream_revision(stream) || raise(StreamNotFoundError, stream) unless stream.all_stream?
 
         queries.events.stream_events(stream, options)
       end

data/lib/pg_eventstore/errors.rb

@@ -58,9 +58,11 @@ module PgEventstore
 
     # @return [String]
     def user_friendly_message
-      return expected_stream_exists if revision == -1 && expected_revision == :stream_exists
-      return expected_no_stream if revision > -1 && expected_revision == :no_stream
-      return current_no_stream if revision == -1 && expected_revision.is_a?(Integer)
+      if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :stream_exists
+        return expected_stream_exists
+      end
+      return expected_no_stream if revision > Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :no_stream
+      return current_no_stream if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision.is_a?(Integer)
 
       unmatched_stream_revision
     end
@@ -189,9 +191,18 @@ module PgEventstore
 
     # @return [String]
     def user_friendly_message
-      <<~TEXT.strip
-        Event#id must be present, got #{event.id.inspect} instead.
-      TEXT
+      "Event with #id #{event.id.inspect} must be present, but it could not be found."
+    end
+  end
+
+  class MissingPartitions < Error
+    attr_reader :stream, :event_types
+
+    # @param stream [PgEventstore::Stream]
+    # @param event_types [Array<String>]
+    def initialize(stream, event_types)
+      @stream = stream
+      @event_types = event_types
     end
   end
 end

data/lib/pg_eventstore/event_deserializer.rb

@@ -24,7 +24,9 @@ module PgEventstore
       middlewares.each do |middleware|
         middleware.deserialize(event)
       end
-      event.stream = PgEventstore::Stream.new(**attrs['stream'].transform_keys(&:to_sym)) if attrs.key?('stream')
+      event.stream = PgEventstore::Stream.new(
+        **attrs.slice('context', 'stream_name', 'stream_id').transform_keys(&:to_sym)
+      )
       event
     end
 

data/lib/pg_eventstore/queries/event_queries.rb

@@ -15,46 +15,89 @@ module PgEventstore
       @deserializer = deserializer
     end
 
+    # @param id [String, nil]
+    # @return [Boolean]
+    def event_exists?(id)
+      return false if id.nil?
+
+      sql_builder = SQLBuilder.new.select('1 as exists').from('events').where('id = ?', id).limit(1)
+      connection.with do |conn|
+        conn.exec_params(*sql_builder.to_exec_params)
+      end.to_a.dig(0, 'exists') == 1
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [Integer, nil]
+    def stream_revision(stream)
+      sql_builder = SQLBuilder.new.from('events').select('stream_revision').
+        where('context = ? and stream_name = ? and stream_id = ?', *stream.to_a).
+        order('stream_revision DESC').
+        limit(1)
+      connection.with do |conn|
+        conn.exec_params(*sql_builder.to_exec_params)
+      end.to_a.dig(0, 'stream_revision')
+    end
+
     # @see PgEventstore::Client#read for more info
     # @param stream [PgEventstore::Stream]
     # @param options [Hash]
     # @return [Array<PgEventstore::Event>]
     def stream_events(stream, options)
-      options = event_type_queries.include_event_types_ids(options)
       exec_params = events_filtering(stream, options).to_exec_params
       raw_events = connection.with do |conn|
         conn.exec_params(*exec_params)
       end.to_a
-      preloader.preload_related_objects(raw_events)
       deserializer.deserialize_many(raw_events)
     end
 
-    # @param stream [PgEventstore::Stream] persisted stream
-    # @param event [PgEventstore::Event]
+    # @param stream [PgEventstore::Stream]
+    # @param events [Array<PgEventstore::Event>]
     # @return [PgEventstore::Event]
-    def insert(stream, event)
-      serializer.serialize(event)
-
-      attributes = event.options_hash.slice(:id, :data, :metadata, :stream_revision, :link_id).compact
-      attributes[:stream_id] = stream.id
-      attributes[:event_type_id] = event_type_queries.find_or_create_type(event.type)
+    def insert(stream, events)
+      sql_rows_for_insert, values = prepared_statements(stream, events)
+      columns = %w[id data metadata stream_revision link_id type context stream_name stream_id]
 
       sql = <<~SQL
-        INSERT INTO events (#{attributes.keys.join(', ')}) 
-          VALUES (#{Utils.positional_vars(attributes.values)}) 
-          RETURNING *, $#{attributes.values.size + 1} as type
+        INSERT INTO events (#{columns.join(', ')}) 
+          VALUES #{sql_rows_for_insert.join(", ")} 
+          RETURNING *
       SQL
 
-      raw_event = connection.with do |conn|
-        conn.exec_params(sql, [*attributes.values, event.type])
-      end.to_a.first
-      deserializer.without_middlewares.deserialize(raw_event).tap do |persisted_event|
-        persisted_event.stream = stream
+      connection.with do |conn|
+        conn.exec_params(sql, values)
+      end.map do |raw_event|
+        deserializer.without_middlewares.deserialize(raw_event)
       end
     end
 
     private
 
+    # @param stream [PgEventstore::Stream]
+    # @param events [Array<PgEventstore::Event>]
+    # @return [Array<Array<String>, Array<Object>>]
+    def prepared_statements(stream, events)
+      positional_counter = 1
+      values = []
+      sql_rows_for_insert = events.map do |event|
+        event = serializer.serialize(event)
+        attributes = event.options_hash.slice(:id, :data, :metadata, :stream_revision, :link_id, :type)
+
+        attributes = attributes.merge(stream.to_hash)
+        prepared = attributes.values.map do |value|
+          if value.nil?
+            'DEFAULT'
+          else
+            "$#{positional_counter}".tap do
+              values.push(value)
+              positional_counter += 1
+            end
+          end
+        end
+        "(#{prepared.join(',')})"
+      end
+      [sql_rows_for_insert, values]
+    end
+
     # @param stream [PgEventstore::Stream]
     # @param options [Hash]
     # @return [PgEventstore::EventsFilteringQuery]
@@ -63,15 +106,5 @@ module PgEventstore
 
       QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options)
     end
-
-    # @return [PgEventstore::EventTypeQueries]
-    def event_type_queries
-      EventTypeQueries.new(connection)
-    end
-
-    # @return [PgEventstore::Preloader]
-    def preloader
-      Preloader.new(connection)
-    end
   end
 end

data/lib/pg_eventstore/queries/partition_queries.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class PartitionQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [Hash] partition attributes
+    def create_context_partition(stream)
+      attributes = { context: stream.context, table_name: context_partition_name(stream) }
+
+      loop do
+        break unless partition_name_taken?(attributes[:table_name])
+
+        attributes[:table_name] = attributes[:table_name].next
+      end
+
+      partition_sql = <<~SQL
+        INSERT INTO partitions (#{attributes.keys.join(', ')})
+          VALUES (#{Utils.positional_vars(attributes.values)}) RETURNING *
+      SQL
+      partition = connection.with do |conn|
+        conn.exec_params(partition_sql, [*attributes.values])
+      end.to_a.first
+      connection.with do |conn|
+        conn.exec(<<~SQL)
+          CREATE TABLE #{attributes[:table_name]} PARTITION OF events
+            FOR VALUES IN('#{conn.escape_string(stream.context)}') PARTITION BY LIST (stream_name)
+        SQL
+      end
+      partition
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @param context_partition_name [String]
+    # @return [Hash] partition attributes
+    def create_stream_name_partition(stream, context_partition_name)
+      attributes = {
+        context: stream.context, stream_name: stream.stream_name, table_name: stream_name_partition_name(stream)
+      }
+
+      loop do
+        break unless partition_name_taken?(attributes[:table_name])
+
+        attributes[:table_name] = attributes[:table_name].next
+      end
+
+      partition_sql = <<~SQL
+        INSERT INTO partitions (#{attributes.keys.join(', ')}) 
+          VALUES (#{Utils.positional_vars(attributes.values)}) RETURNING *
+      SQL
+      partition = connection.with do |conn|
+        conn.exec_params(partition_sql, [*attributes.values])
+      end.to_a.first
+      connection.with do |conn|
+        conn.exec(<<~SQL)
+          CREATE TABLE #{attributes[:table_name]} PARTITION OF #{context_partition_name}
+            FOR VALUES IN('#{conn.escape_string(stream.stream_name)}') PARTITION BY LIST (type)
+        SQL
+      end
+      partition
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @param stream_name_partition_name [String]
+    # @return [Hash] partition attributes
+    def create_event_type_partition(stream, event_type, stream_name_partition_name)
+      attributes = {
+        context: stream.context, stream_name: stream.stream_name, event_type: event_type,
+        table_name: event_type_partition_name(stream, event_type)
+      }
+
+      loop do
+        break unless partition_name_taken?(attributes[:table_name])
+
+        attributes[:table_name] = attributes[:table_name].next
+      end
+
+      partition_sql = <<~SQL
+        INSERT INTO partitions (#{attributes.keys.join(', ')}) 
+          VALUES (#{Utils.positional_vars(attributes.values)}) RETURNING *
+      SQL
+      partition = connection.with do |conn|
+        conn.exec_params(partition_sql, [*attributes.values])
+      end.to_a.first
+      connection.with do |conn|
+        conn.exec(<<~SQL)
+          CREATE TABLE #{attributes[:table_name]} PARTITION OF #{stream_name_partition_name}
+            FOR VALUES IN('#{conn.escape_string(event_type)}')
+        SQL
+      end
+      partition
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @param event_type [String]
+    # @return [Boolean]
+    def partition_required?(stream, event_type)
+      event_type_partition(stream, event_type).nil?
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @param event_type [String]
+    # @return [void]
+    def create_partitions(stream, event_type)
+      return unless partition_required?(stream, event_type)
+
+      context_partition = context_partition(stream) || create_context_partition(stream)
+      stream_name_partition = stream_name_partition(stream) ||
+        create_stream_name_partition(stream, context_partition['table_name'])
+
+      create_event_type_partition(stream, event_type, stream_name_partition['table_name'])
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [Hash, nil] partition attributes
+    def context_partition(stream)
+      connection.with do |conn|
+        conn.exec_params(
+          'select * from partitions where context = $1 and stream_name is null and event_type is null',
+          [stream.context]
+        )
+      end.first
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [Hash, nil] partition attributes
+    def stream_name_partition(stream)
+      connection.with do |conn|
+        conn.exec_params(
+          <<~SQL,
+            select * from partitions where context = $1 and stream_name = $2 and event_type is null
+          SQL
+          [stream.context, stream.stream_name]
+        )
+      end.first
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @param event_type [String]
+    # @return [Hash, nil] partition attributes
+    def event_type_partition(stream, event_type)
+      connection.with do |conn|
+        conn.exec_params(
+          <<~SQL,
+            select * from partitions where context = $1 and stream_name = $2 and event_type = $3
+          SQL
+          [stream.context, stream.stream_name, event_type]
+        )
+      end.first
+    end
+
+    # @param table_name [String]
+    # @return [Boolean]
+    def partition_name_taken?(table_name)
+      connection.with do |conn|
+        conn.exec_params('select 1 as exists from partitions where table_name = $1', [table_name])
+      end.to_a.dig(0, 'exists') == 1
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [String]
+    def context_partition_name(stream)
+      "contexts_#{Digest::MD5.hexdigest(stream.context)[0..5]}"
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [String]
+    def stream_name_partition_name(stream)
+      "stream_names_#{Digest::MD5.hexdigest("#{stream.context}-#{stream.stream_name}")[0..5]}"
+    end
+
+    def event_type_partition_name(stream, event_type)
+      "event_types_#{Digest::MD5.hexdigest("#{stream.context}-#{stream.stream_name}-#{event_type}")[0..5]}"
+    end
+  end
+end

data/lib/pg_eventstore/queries/subscription_queries.rb

@@ -79,10 +79,9 @@ module PgEventstore
       return [] if query_options.empty?
 
       final_builder = union_builders(query_options.map { |id, opts| query_builder(id, opts) })
-      raw_events = connection.with do |conn|
+      connection.with do |conn|
         conn.exec_params(*final_builder.to_exec_params)
       end.to_a
-      preloader.preload_related_objects(raw_events)
     end
 
     # @param id [Integer] subscription's id
@@ -128,9 +127,7 @@ module PgEventstore
     # @param options [Hash] query options
     # @return [PgEventstore::SQLBuilder]
     def query_builder(id, options)
-      builder = PgEventstore::QueryBuilders::EventsFiltering.subscriptions_events_filtering(
-        event_type_queries.include_event_types_ids(options)
-      ).to_sql_builder
+      builder = PgEventstore::QueryBuilders::EventsFiltering.subscriptions_events_filtering(options).to_sql_builder
       builder.select("#{id} as runner_id")
     end
 
@@ -152,11 +149,6 @@ module PgEventstore
       EventTypeQueries.new(connection)
     end
 
-    # @return [PgEventstore::Preloader]
-    def preloader
-      Preloader.new(connection)
-    end
-
     # @param hash [Hash]
     # @return [Hash]
     def deserialize(hash)

data/lib/pg_eventstore/queries/transaction_queries.rb

@@ -36,6 +36,19 @@ module PgEventstore
       end
     rescue PG::TRSerializationFailure, PG::TRDeadlockDetected
       retry
+    rescue MissingPartitions => error
+      error.event_types.each do |event_type|
+        transaction do
+          partition_queries.create_partitions(error.stream, event_type)
+        end
+      rescue PG::UniqueViolation
+        retry
+      end
+      retry
+    end
+
+    def partition_queries
+      PartitionQueries.new(connection)
     end
   end
 end

data/lib/pg_eventstore/queries.rb

@@ -4,13 +4,11 @@ require_relative 'sql_builder'
 require_relative 'query_builders/events_filtering_query'
 require_relative 'queries/transaction_queries'
 require_relative 'queries/event_queries'
-require_relative 'queries/stream_queries'
-require_relative 'queries/event_type_queries'
+require_relative 'queries/partition_queries'
 require_relative 'queries/subscription_queries'
 require_relative 'queries/subscriptions_set_queries'
 require_relative 'queries/subscription_command_queries'
 require_relative 'queries/subscriptions_set_command_queries'
-require_relative 'queries/preloader'
 
 module PgEventstore
   # @!visibility private
@@ -20,9 +18,9 @@ module PgEventstore
     # @!attribute events
     #   @return [PgEventstore::EventQueries, nil]
     attribute(:events)
-    # @!attribute streams
-    #   @return [PgEventstore::StreamQueries, nil]
-    attribute(:streams)
+    # @!attribute partitions
+    #   @return [PgEventstore::PartitionQueries, nil]
+    attribute(:partitions)
     # @!attribute transactions
     #   @return [PgEventstore::TransactionQueries, nil]
     attribute(:transactions)

data/lib/pg_eventstore/query_builders/events_filtering_query.rb

@@ -28,7 +28,7 @@ module PgEventstore
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def all_stream_filtering(options)
           event_filter = new
-          options in { filter: { event_type_ids: Array => event_type_ids } }
+          options in { filter: { event_types: Array => event_type_ids } }
           event_filter.add_event_types(event_type_ids)
           event_filter.add_limit(options[:max_count])
           event_filter.resolve_links(options[:resolve_link_tos])
@@ -44,11 +44,11 @@ module PgEventstore
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def specific_stream_filtering(stream, options)
           event_filter = new
-          options in { filter: { event_type_ids: Array => event_type_ids } }
+          options in { filter: { event_types: Array => event_type_ids } }
           event_filter.add_event_types(event_type_ids)
           event_filter.add_limit(options[:max_count])
           event_filter.resolve_links(options[:resolve_link_tos])
-          event_filter.add_stream(stream)
+          event_filter.add_stream_attrs(**stream.to_hash)
           event_filter.add_revision(options[:from_revision], options[:direction])
           event_filter.add_stream_direction(options[:direction])
           event_filter
@@ -60,8 +60,6 @@ module PgEventstore
           SQLBuilder.new.
             select('events.*').
             from('events').
-            join('JOIN streams ON streams.id = events.stream_id').
-            join('JOIN event_types ON event_types.id = events.event_type_id').
             limit(DEFAULT_LIMIT)
       end
 
@@ -75,27 +73,21 @@ module PgEventstore
 
         stream_attrs.compact!
         sql = stream_attrs.map do |attr, _|
-          "streams.#{attr} = ?"
+          "events.#{attr} = ?"
         end.join(" AND ")
         @sql_builder.where_or(sql, *stream_attrs.values)
       end
 
-      # @param stream [PgEventstore::Stream]
+      # @param event_types [Array<String>, nil]
       # @return [void]
-      def add_stream(stream)
-        @sql_builder.where("streams.id = ?", stream.id)
-      end
-
-      # @param event_type_ids [Array<Integer>, nil]
-      # @return [void]
-      def add_event_types(event_type_ids)
-        return if event_type_ids.nil?
-        return if event_type_ids.empty?
+      def add_event_types(event_types)
+        return if event_types.nil?
+        return if event_types.empty?
 
-        sql = event_type_ids.size.times.map do
+        sql = event_types.size.times.map do
           "?"
         end.join(", ")
-        @sql_builder.where("events.event_type_id IN (#{sql})", *event_type_ids)
+        @sql_builder.where("events.type IN (#{sql})", *event_types)
       end
 
       # @param revision [Integer, nil]

data/lib/pg_eventstore/rspec/test_helpers.rb

@@ -4,10 +4,25 @@ module PgEventstore
   module TestHelpers
     class << self
       def clean_up_db
+        clean_up_data
+        clean_up_partitions
+      end
+
+      def clean_up_partitions
+        PgEventstore.connection.with do |conn|
+          # Dropping parent partition also drops all child partitions
+          conn.exec("select tablename from pg_tables where tablename like 'contexts_%'").each do |attrs|
+            conn.exec("drop table #{attrs['tablename']}")
+          end
+        end
+      end
+
+      def clean_up_data
         tables_to_purge = PgEventstore.connection.with do |conn|
           conn.exec(<<~SQL)
             SELECT tablename 
-            FROM pg_catalog.pg_tables WHERE schemaname NOT IN ('pg_catalog', 'information_schema') AND tablename != 'migrations'                
+            FROM pg_catalog.pg_tables 
+            WHERE schemaname NOT IN ('pg_catalog', 'information_schema') AND tablename != 'migrations'
           SQL
         end.map { |attrs| attrs['tablename'] }
         tables_to_purge.each do |table_name|

data/lib/pg_eventstore/sql_builder.rb

@@ -9,6 +9,7 @@ module PgEventstore
       @from_value = nil
       @where_values = { 'AND' => [], 'OR' => [] }
       @join_values = []
+      @group_values = []
       @order_values = []
       @limit_value = nil
       @offset_value = nil
@@ -68,6 +69,11 @@ module PgEventstore
       self
     end
 
+    def remove_order
+      @order_values.clear
+      self
+    end
+
     # @param limit [Integer]
     # @return self
     def limit(limit)
@@ -75,6 +81,11 @@ module PgEventstore
       self
     end
 
+    def remove_limit
+      @limit_value = nil
+      self
+    end
+
     # @param offset [Integer]
     # @return self
     def offset(offset)
@@ -89,10 +100,22 @@ module PgEventstore
       self
     end
 
-    def to_exec_params
-      return [single_query_sql, @positional_values] if @union_values.empty?
+    # @param sql [String]
+    # @return self
+    def group(sql)
+      @group_values.push(sql)
+      self
+    end
 
-      [union_query_sql, @positional_values]
+    def remove_group
+      @group_values.clear
+      self
+    end
+
+    def to_exec_params
+      @positional_values.clear
+      @positional_values_size = 0
+      _to_exec_params
     end
 
     protected
@@ -106,6 +129,12 @@ module PgEventstore
       @positional_values_size = val
     end
 
+    def _to_exec_params
+      return [single_query_sql, @positional_values] if @union_values.empty?
+
+      [union_query_sql, @positional_values]
+    end
+
     private
 
     # @return [String]
@@ -114,6 +143,7 @@ module PgEventstore
       sql = "SELECT #{select_sql} FROM #{@from_value}"
       sql += " #{join_sql}" unless @join_values.empty?
       sql += " WHERE #{where_sql}" unless where_sql.empty?
+      sql += " GROUP BY #{@group_values.join(', ')}" unless @group_values.empty?
       sql += " ORDER BY #{order_sql}" unless @order_values.empty?
       sql += " LIMIT #{@limit_value}" if @limit_value
       sql += " OFFSET #{@offset_value}" if @offset_value
@@ -126,7 +156,7 @@ module PgEventstore
       union_parts = ["(#{sql})"]
       union_parts += @union_values.map do |builder|
         builder.positional_values_size = @positional_values_size
-        builder_sql, values = builder.to_exec_params
+        builder_sql, values = builder._to_exec_params
         @positional_values.push(*values)
         @positional_values_size += values.size
         "(#{builder_sql})"

data/lib/pg_eventstore/stream.rb

@@ -5,7 +5,7 @@ require 'digest/md5'
 module PgEventstore
   class Stream
     SYSTEM_STREAM_PREFIX = '$'
-    INITIAL_STREAM_REVISION = -1 # this is the default value of streams.stream_revision column
+    NON_EXISTING_STREAM_REVISION = -1
 
     class << self
       # Produces "all" stream instance. "all" stream does not represent any specific stream. Instead, it indicates that
@@ -18,20 +18,15 @@ module PgEventstore
       end
     end
 
-    attr_reader :context, :stream_name, :stream_id, :id
-    attr_accessor :stream_revision
+    attr_reader :context, :stream_name, :stream_id
 
     # @param context [String]
     # @param stream_name [String]
     # @param stream_id [String]
-    # @param id [Integer, nil] internal stream's id, read only
-    # @param stream_revision [Integer, nil] current stream revision, read only
-    def initialize(context:, stream_name:, stream_id:, id: nil, stream_revision: nil)
+    def initialize(context:, stream_name:, stream_id:)
       @context = context
       @stream_name = stream_name
       @stream_id = stream_id
-      @id = id
-      @stream_revision = stream_revision
     end
 
     # @return [Boolean]

data/lib/pg_eventstore/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgEventstore
-  VERSION = "0.8.0"
+  VERSION = "0.10.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_eventstore
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-02-20 00:00:00.000000000 Z
+date: 2024-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -50,16 +50,15 @@ files:
 - LICENSE.txt
 - README.md
 - db/migrations/0_create_extensions.sql
-- db/migrations/1_create_streams.sql
-- db/migrations/2_create_event_types.sql
-- db/migrations/3_create_events.sql
-- db/migrations/4_create_subscriptions.sql
-- db/migrations/5_create_subscription_commands.sql
-- db/migrations/6_create_subscriptions_set_commands.sql
-- db/migrations/7_change_subscriptions_chunk_query_interval_type.sql
+- db/migrations/1_create_events.sql
+- db/migrations/2_create_subscriptions.sql
+- db/migrations/3_create_subscription_commands.sql
+- db/migrations/4_create_subscriptions_set_commands.sql
+- db/migrations/5_partitions.sql
 - docs/appending_events.md
 - docs/configuration.md
 - docs/events_and_streams.md
+- docs/how_it_works.md
 - docs/linking_events.md
 - docs/multiple_commands.md
 - docs/reading_events.md
@@ -92,9 +91,7 @@ files:
 - lib/pg_eventstore/pg_connection.rb
 - lib/pg_eventstore/queries.rb
 - lib/pg_eventstore/queries/event_queries.rb
-- lib/pg_eventstore/queries/event_type_queries.rb
-- lib/pg_eventstore/queries/preloader.rb
-- lib/pg_eventstore/queries/stream_queries.rb
+- lib/pg_eventstore/queries/partition_queries.rb
 - lib/pg_eventstore/queries/subscription_command_queries.rb
 - lib/pg_eventstore/queries/subscription_queries.rb
 - lib/pg_eventstore/queries/subscriptions_set_command_queries.rb

data/db/migrations/1_create_streams.sql

@@ -1,13 +0,0 @@
-CREATE TABLE public.streams
-(
-    id              bigserial                     NOT NULL,
-    context         character varying             NOT NULL,
-    stream_name     character varying             NOT NULL,
-    stream_id       character varying             NOT NULL,
-    stream_revision integer DEFAULT '-1'::integer NOT NULL
-);
-
-ALTER TABLE ONLY public.streams
-    ADD CONSTRAINT streams_pkey PRIMARY KEY (id);
-
-CREATE UNIQUE INDEX idx_streams_context_and_stream_name_and_stream_id ON public.streams USING btree (context, stream_name, stream_id);

data/db/migrations/2_create_event_types.sql

@@ -1,10 +0,0 @@
-CREATE TABLE public.event_types
-(
-    id   bigserial         NOT NULL,
-    type character varying NOT NULL
-);
-
-ALTER TABLE ONLY public.event_types
-    ADD CONSTRAINT event_types_pkey PRIMARY KEY (id);
-
-CREATE UNIQUE INDEX idx_event_types_type ON public.event_types USING btree (type);

data/db/migrations/7_change_subscriptions_chunk_query_interval_type.sql

@@ -1,2 +0,0 @@
-ALTER TABLE public.subscriptions ALTER COLUMN chunk_query_interval SET DATA TYPE float4;
-ALTER TABLE public.subscriptions ALTER COLUMN chunk_query_interval SET DEFAULT 1.0;

data/lib/pg_eventstore/queries/event_type_queries.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module PgEventstore
-  # @!visibility private
-  class EventTypeQueries
-    attr_reader :connection
-    private :connection
-
-    # @param connection [PgEventstore::Connection]
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # @param type [String]
-    # @return [Integer] event type's id
-    def find_or_create_type(type)
-      find_type(type) || create_type(type)
-    end
-
-    # @param type [String]
-    # @return [Integer, nil] event type's id
-    def find_type(type)
-      connection.with do |conn|
-        conn.exec_params('SELECT id FROM event_types WHERE type = $1', [type])
-      end.to_a.dig(0, 'id')
-    end
-
-    # @param type [String]
-    # @return [Integer] event type's id
-    def create_type(type)
-      connection.with do |conn|
-        conn.exec_params('INSERT INTO event_types (type) VALUES ($1) RETURNING id', [type])
-      end.to_a.dig(0, 'id')
-    end
-
-    # @param ids [Array<Integer>]
-    # @return [Array<Hash>]
-    def find_by_ids(ids)
-      return [] if ids.empty?
-
-      builder = SQLBuilder.new.from('event_types').where('id = ANY(?)', ids.uniq)
-      connection.with do |conn|
-        conn.exec_params(*builder.to_exec_params)
-      end.to_a
-    end
-
-    # @param types [Array<String>]
-    # @return [Array<Integer, nil>]
-    def find_event_types(types)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [types])
-          SELECT event_types.id, types.type
-            FROM event_types 
-            RIGHT JOIN (
-              SELECT unnest($1::varchar[]) as type
-            ) types ON types.type = event_types.type
-        SQL
-      end.to_a.map { |attrs| attrs['id'] }
-    end
-
-    # Replaces filter by event type strings with filter by event type ids
-    # @param options [Hash]
-    # @return [Hash]
-    def include_event_types_ids(options)
-      options in { filter: { event_types: Array => event_types } }
-      return options unless event_types
-
-      options = Utils.deep_dup(options)
-      options[:filter][:event_type_ids] = find_event_types(event_types).uniq
-      options[:filter].delete(:event_types)
-      options
-    end
-  end
-end

data/lib/pg_eventstore/queries/preloader.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module PgEventstore
-  # @!visibility private
-  class Preloader
-    attr_reader :connection
-    private :connection
-
-    # @param connection [PgEventstore::Connection]
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # @param raw_events [Array<Hash>]
-    # @return [Array<Hash>]
-    def preload_related_objects(raw_events)
-      streams = stream_queries.find_by_ids(raw_events.map { _1['stream_id'] }).to_h { [_1['id'], _1] }
-      types = event_type_queries.find_by_ids(raw_events.map { _1['event_type_id'] }).to_h { [_1['id'], _1] }
-      raw_events.each do |event|
-        event['stream'] = streams[event['stream_id']]
-        event['type'] = types[event['event_type_id']]['type']
-      end
-    end
-
-    private
-
-    # @return [PgEventstore::EventTypeQueries]
-    def event_type_queries
-      EventTypeQueries.new(connection)
-    end
-
-    # @return [PgEventstore::StreamQueries]
-    def stream_queries
-      StreamQueries.new(connection)
-    end
-  end
-end

data/lib/pg_eventstore/queries/stream_queries.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module PgEventstore
-  # @!visibility private
-  class StreamQueries
-    attr_reader :connection
-    private :connection
-
-    # @param connection [PgEventstore::Connection]
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # Finds a stream in the database by the given Stream object
-    # @param stream [PgEventstore::Stream]
-    # @return [PgEventstore::Stream, nil] persisted stream
-    def find_stream(stream)
-      builder =
-        SQLBuilder.new.
-          from('streams').
-          where('streams.context = ? AND streams.stream_name = ? AND streams.stream_id = ?', *stream.to_a).
-          limit(1)
-      pg_result = connection.with do |conn|
-        conn.exec_params(*builder.to_exec_params)
-      end
-      deserialize(pg_result) if pg_result.ntuples == 1
-    end
-
-    # @param ids [Array<Integer>]
-    # @return [Array<Hash>]
-    def find_by_ids(ids)
-      return [] if ids.empty?
-
-      builder = SQLBuilder.new.from('streams').where('id = ANY(?)', ids.uniq.sort)
-      connection.with do |conn|
-        conn.exec_params(*builder.to_exec_params)
-      end.to_a
-    end
-
-    # @param stream [PgEventstore::Stream]
-    # @return [PgEventstore::RawStream] persisted stream
-    def create_stream(stream)
-      create_sql = <<~SQL
-        INSERT INTO streams (context, stream_name, stream_id) VALUES ($1, $2, $3) RETURNING *
-      SQL
-      pg_result = connection.with do |conn|
-        conn.exec_params(create_sql, stream.to_a)
-      end
-      deserialize(pg_result)
-    end
-
-    # @return [PgEventstore::Stream] persisted stream
-    def find_or_create_stream(stream)
-      find_stream(stream) || create_stream(stream)
-    end
-
-    # @param stream [PgEventstore::Stream] persisted stream
-    # @return [PgEventstore::Stream]
-    def update_stream_revision(stream, revision)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [revision, stream.id])
-          UPDATE streams SET stream_revision = $1 WHERE id = $2
-        SQL
-      end
-      stream.stream_revision = revision
-      stream
-    end
-
-    private
-
-    # @param pg_result [PG::Result]
-    # @return [PgEventstore::Stream, nil]
-    def deserialize(pg_result)
-      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym))
-    end
-  end
-end