pg_eventstore 0.9.0 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ca951a11a040b193a289feb28627294328acebaa929730928749ddddeb41a83
-  data.tar.gz: 4af9d3c3ee4b4b4ce77092bc699cb1ad97d9a9f8e5fde4ff9d1d8078c2385efc
+  metadata.gz: ccfbe47f6f178820e5f7b5ccc9fb9298bf6beba4fa10081cd01bcd6ce3fe1001
+  data.tar.gz: b55180dc1c24ec04d13e99b0d4ba920eae5eef652ccde632f332ab67b27cc14e
 SHA512:
-  metadata.gz: 68baa83af9884c14f312e85f4ef619dd9365ffc273b0a629b14c466f25d393de884c2fdca02849b03f40a87535f6253751d3bc4eb1d702e630cceb0fd511c0a7
-  data.tar.gz: e2c14d9b5767c3a55dda6a594345159e11c5a5e04c18060ddcb587ba40a011be84936c0a36c746ad40928d97a321e468890b37108c0129e4cdb2bda17996d4a5
+  metadata.gz: 4226be0aa1f6109b5a956febca5343b1a1d215c6a16e056267027287bcb629295cd4af1a7f6fc093e781c90a48f885f2b5932faff7962bdd993305519bfca053
+  data.tar.gz: 2eb04ad6b29569f29282768e806813823e990493674c627252963d312966aa1806f06139b4b01937699c0fcf4b25034c2e02cb7375710d65838d62bb3934099d

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.10.2] - 2024-03-13
+
+- Review the approach to resolve link events 
+- Fix subscriptions restart interval option not being processed correctly
+
+## [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

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/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/configuration.md

@@ -10,7 +10,7 @@ Configuration options:
 | event_class_resolver               | `#call` | `PgEventstore::EventClassResolver.new`                       | A `#call`-able object that accepts a string and returns an event's class. See **Resolving events classes** chapter bellow for more info.                                                                                                                                                                               |
 | connection_pool_size               | Integer | `5`                                                          | Max number of connections per ruby process. It must equal the number of threads of your application. When using subscriptions it is recommended to set it to the number of subscriptions divided by two or greater. See [**Picking max connections number**](#picking-max-connections-number) chapter of this section. |
 | connection_pool_timeout            | Integer | `5`                                                          | Time in seconds to wait for a connection in the pool to be released. If no connections are available during this time - `ConnectionPool::TimeoutError` will be raised. See `connection_pool` gem [docs](https://github.com/mperham/connection_pool#usage) for more info.                                               |
-| subscription_pull_interval         | Float   | `1.0`                                                        | How often to pull new subscription events in seconds.                                                                                                                                                                                                                                                                  |
+| subscription_pull_interval         | Float   | `1.0`                                                        | How often to pull new subscription events in seconds. The minimum meaningful value is `0.2`. Values less than `0.2` will act as it is `0.2`.                                                                                                                                                                           |
 | subscription_max_retries           | Integer | `5`                                                          | Max number of retries of failed subscription.                                                                                                                                                                                                                                                                          |
 | subscription_retries_interval      | Integer | `1`                                                          | Interval in seconds between retries of failed subscriptions.                                                                                                                                                                                                                                                           |
 | subscriptions_set_max_retries      | Integer | `10`                                                         | Max number of retries for failed subscription sets.                                                                                                                                                                                                                                                                    |

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.rb

@@ -31,6 +31,10 @@ module PgEventstore
     #   @return [String, nil] UUIDv4 of an event the current event points to. If it is not nil, then the current
     #     event is a link
     attribute(:link_id)
+    # @!attribute link
+    #   @return [PgEventstore::Event, nil] when resolve_link_tos: true option is provided during the read of events and
+    #     event is a link event - this attribute will be pointing on that link
+    attribute(:link)
     # @!attribute created_at
     #   @return [Time, nil] a timestamp an event was created at
     attribute(:created_at)
@@ -41,7 +45,7 @@ module PgEventstore
     def ==(other)
       return false unless other.is_a?(PgEventstore::Event)
 
-      attributes_hash == other.attributes_hash
+      attributes_hash.except(:link) == other.attributes_hash.except(:link)
     end
 
     # Detect whether an event is a link event

data/lib/pg_eventstore/event_deserializer.rb

@@ -24,7 +24,10 @@ 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.link = without_middlewares.deserialize(attrs['link']) if attrs.key?('link')
       event
     end
 

data/lib/pg_eventstore/queries/event_queries.rb

@@ -15,46 +15,90 @@ 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)
+      raw_events = links_resolver.resolve(raw_events) if options[:resolve_link_tos]
       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]
@@ -64,14 +108,9 @@ 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)
+    # @return [PgEventstore::LinksResolver]
+    def links_resolver
+      LinksResolver.new(connection)
     end
   end
 end

data/lib/pg_eventstore/queries/links_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class LinksResolver
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param raw_events [Array<Hash>]
+    def resolve(raw_events)
+      ids = raw_events.map { _1['link_id'] }.compact.uniq
+      return raw_events if ids.empty?
+
+      original_events = connection.with do |conn|
+        conn.exec_params('select * from events where id = ANY($1::uuid[])', [ids])
+      end.to_h { |attrs| [attrs['id'], attrs] }
+
+      raw_events.map do |attrs|
+        original_event = original_events[attrs['link_id']]
+        next attrs unless original_event
+
+        original_event.merge('link' => attrs).merge(attrs.except(*original_event.keys))
+      end
+    end
+  end
+end