pg_eventstore 1.13.4 → 3.0.0

data/lib/pg_eventstore/queries/events_global_index_queries.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class EventsGlobalIndexQueries
+    # @!attribute connection
+    #   @return [PgEventstore::Connection]
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    # @param query_strategy [PgEventstore::QueryStrategy]
+    def initialize(connection, query_strategy)
+      @connection = connection
+      @query_strategy = query_strategy
+    end
+
+    # @param raw_events [Array<Hash>]
+    # @param affected_partitions [Array<PgEventstore::Partition>]
+    # @param stream_index_id [Integer]
+    # @return [Array<PgEventstore::EventGlobalIndex::WriteApiRepr>]
+    def index_events(raw_events, affected_partitions, stream_index_id)
+      partitions = affected_partitions.to_h { [_1.event_type, _1] }
+      values = raw_events.map do |event_attrs|
+        values = [
+          event_attrs['global_position'],
+          event_attrs['stream_revision'],
+          partitions[event_attrs['type']].parent_context_partition_id,
+          partitions[event_attrs['type']].parent_stream_name_partition_id,
+          partitions[event_attrs['type']].id,
+          stream_index_id,
+        ]
+        "(#{values.join(', ')})"
+      end
+      values = values.join(',')
+
+      result = @query_strategy.exec(<<~SQL)
+        INSERT INTO events_global_index
+          ("global_position", "stream_revision", "context_partition_id", "stream_name_partition_id",
+           "event_type_partition_id", "streams_global_index_id")
+        VALUES #{values}
+        RETURNING global_position, stream_revision, event_type_partition_id
+      SQL
+      # "returning" statement has no guarantees about the order in which rows are returned. Thus, sort them explicitly
+      deserialize(result, repr: EventGlobalIndex::ReprType::WRITE_API).sort_by(&:stream_revision)
+    end
+
+    # @param grouped_opts [Hash]
+    # @return [Hash<Integer, Array<PgEventstore::SubscriptionRepr>>]
+    def fetch_indexes_for_subscriptions(grouped_opts)
+      builders = grouped_opts.map do |subscription_id, opts|
+        filter = QueryBuilders::SubscriptionEventsFiltering.build(subscription_id, opts)
+        filter.to_sql_builder.select("#{subscription_id} as subscription_id")
+      end
+      final_builder = SQLBuilder.union_builders(builders)
+      res = @query_strategy.exec_params(*final_builder.to_exec_params)
+      res = res.group_by { _1['subscription_id'] }
+      res.to_h do |sid, indexes|
+        [
+          sid,
+          indexes.map do |attrs|
+            EventGlobalIndex::SubscriptionRepr.new(**attrs.except('subscription_id').transform_keys(&:to_sym))
+          end,
+        ]
+      end
+    end
+
+    # @param indexes [Array<EventGlobalIndex::ReadApiRepr>, Array<EventGlobalIndex::SubscriptionRepr>]
+    # @param resolve_link_tos [Boolean]
+    # @param direction [String, Symbol, nil]
+    # @return [Array<Hash>]
+    def resolve_indexes(indexes, resolve_link_tos:, direction: nil)
+      indexes = indexes.group_by(&:event_type_partition_id)
+      partitions = partition_queries.find_by_ids(indexes.keys).to_h { [_1['id'], _1] }
+      builders = indexes.map do |partition_id, idxs|
+        partition = partitions[partition_id]
+        events_filtering = QueryBuilders::EventsFiltering.new
+        events_filtering.add_stream_attrs(context: partition['context'], stream_name: partition['stream_name'])
+        events_filtering.add_event_types([partition['event_type']])
+        builder = events_filtering.to_sql_builder
+        builder.where('global_position = ANY(?)', idxs.map(&:global_position))
+      end
+      main_builder = SQLBuilder.union_builders(builders)
+      with_sorted_events = SQLBuilder.new.select('*').from(main_builder)
+      if direction
+        with_sorted_events.order("global_position #{QueryBuilders::BasicFiltering::SQL_DIRECTIONS[direction]}")
+      end
+      raw_events = @query_strategy.exec_params(*with_sorted_events.to_exec_params).to_a
+      resolve_link_tos ? links_resolver.resolve(raw_events) : raw_events
+    end
+
+    # @return [Integer, nil]
+    def max_global_position
+      builder = SQLBuilder.new.from(QueryBuilders::EventsGlobalIndexFiltering::PRIMARY_TABLE_NAME)
+      builder.select('max(global_position) as max_global_position')
+      @query_strategy.exec_params(*builder.to_exec_params).first['max_global_position']
+    end
+
+    # Takes an array of potentially persisted events and loads their ids from db. Those ids can be later used to check
+    # whether events are actually existing events.
+    # @param events [Array<PgEventstore::Event>]
+    # @return [Array<Integer>]
+    def global_positions_from_db(events)
+      builder = SQLBuilder.new.from(QueryBuilders::EventsGlobalIndexFiltering::PRIMARY_TABLE_NAME)
+      builder.where('global_position = ANY(?::bigint[])', events.map(&:global_position))
+      @query_strategy.exec_params(*builder.to_exec_params).map { _1['global_position'] }
+    end
+
+    private
+
+    # @return [PgEventstore::PartitionQueries]
+    def partition_queries
+      PartitionQueries.new(connection)
+    end
+
+    # @return [PgEventstore::LinksResolver]
+    def links_resolver
+      LinksResolver.new(connection, @query_strategy)
+    end
+
+    # @param repr [Symbol, nil]
+    # @return [Array<PgEventstore::EventGlobalIndex>, Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>,
+    #   Array<PgEventstore::EventGlobalIndex::ReadApiRepr>, Array<PgEventstore::EventGlobalIndex::WriteApiRepr>,
+    #   Array<PgEventstore::EventGlobalIndex::RevisionCheckRepr>]
+    def deserialize(pg_result, repr: nil)
+      pg_result.map do |attrs|
+        EventGlobalIndex.create_representation(attrs.transform_keys(&:to_sym), repr:)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/queries/index_filtering_queries.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class IndexFilteringQueries
+    # @!attribute connection
+    #   @return [PgEventstore::Connection]
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    # @param query_strategy [PgEventstore::QueryStrategy]
+    def initialize(connection, query_strategy)
+      @connection = connection
+      @query_strategy = query_strategy
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @param expected_revisions [Array<PgEventstore::Commands::RevisionCheck::ExpectedRevision::EventTypeRevision,
+    #   PgEventstore::Commands::RevisionCheck::ExpectedRevision::EventTypeRevisionWithMarkers,
+    #   PgEventstore::Commands::RevisionCheck::ExpectedRevision::MarkersRevision>]
+    # @return [Array<PgEventstore::EventGlobalIndex::RevisionCheckRepr>]
+    def fetch_indexes_for_revision_validation(stream, expected_revisions)
+      builders = expected_revisions.map do |expected_revision|
+        case expected_revision
+        when Commands::RevisionCheck::ExpectedRevision::EventTypeRevision
+          QueryBuilders::IndexBasedEventsFiltering.sql_builder_for_event_type_revision_validation(
+            stream, expected_revision
+          )
+        when Commands::RevisionCheck::ExpectedRevision::EventTypeRevisionWithMarkers
+          QueryBuilders::IndexBasedEventsFiltering.sql_builder_for_event_type_with_markers_revision_validation(
+            stream, expected_revision
+          )
+        when Commands::RevisionCheck::ExpectedRevision::MarkersRevision
+          QueryBuilders::IndexBasedEventsFiltering.sql_builder_for_markers_revision_validation(
+            stream, expected_revision
+          )
+        else
+          Utils.missing_implementation!(expected_revision)
+        end
+      end
+      final = SQLBuilder.union_builders(builders)
+      deserialize(@query_strategy.exec_params(*final.to_exec_params), repr: EventGlobalIndex::ReprType::REVISION_CHECK)
+    end
+
+    # @param filters_collection [PgEventstore::QueryBuilders::Filters::Collection]
+    # @param cursor [PgEventstore::QueryBuilders::ReadCursor::StreamCursor]
+    # @return [Array<PgEventstore::EventGlobalIndex::ReadApiRepr>]
+    def fetch_indexes_for_read_api(filters_collection, cursor)
+      filter_rows =
+        if filters_collection.collection.any?(&:ambiguous_event_type?)
+          expand_event_types(filters_collection)
+        else
+          filters_collection.collection
+        end
+
+      sql_builder = QueryBuilders::IndexBasedEventsFiltering.sql_builder_for_read_common(filter_rows, cursor)
+      deserialize(@query_strategy.exec_params(*sql_builder.to_exec_params), repr: EventGlobalIndex::ReprType::READ_API)
+    end
+
+    # @param filters_collection [PgEventstore::QueryBuilders::Filters::Collection]
+    # @param cursor [PgEventstore::QueryBuilders::ReadCursor::StreamCursor]
+    # @return [Array<PgEventstore::EventGlobalIndex::ReadApiRepr>]
+    def fetch_grouped_indexes_for_read_api(filters_collection, cursor)
+      filter_rows =
+        if filters_collection.collection.any?(&:ambiguous_event_type?)
+          expand_event_types(filters_collection)
+        else
+          filters_collection.collection
+        end
+
+      sql_builder = QueryBuilders::IndexBasedEventsFiltering.sql_builder_for_read_grouped(filter_rows, cursor)
+      deserialize(@query_strategy.exec_params(*sql_builder.to_exec_params), repr: EventGlobalIndex::ReprType::READ_API)
+    end
+
+    # @param indexes [Array<PgEventstore::EventGlobalIndex::ReadApiRepr>]
+    # @param resolve_link_tos [Boolean]
+    # @return [PgEventstore::Chunks::Repository]
+    def compute_read_api_chunks_repo(indexes, resolve_link_tos)
+      repo = Chunks::Repository.new
+      repo.add_chunk(Chunks::ReadApiEventsIndexChunk.new(indexes, connection, @query_strategy, resolve_link_tos))
+      repo
+    end
+
+    private
+
+    # @return [PgEventstore::PartitionQueries]
+    def partition_queries
+      PartitionQueries.new(connection)
+    end
+
+    # @param filters_collection [PgEventstore::QueryBuilders::Filters::Collection]
+    # @return [Array<PgEventstore::QueryBuilders::Filters::FilterRow>]
+    def expand_event_types(filters_collection)
+      filter_rows = filters_collection.collection
+      to_expand = filter_rows.select(&:ambiguous_event_type?)
+      rest_filter_rows = filter_rows - to_expand
+      partition_builders = to_expand.map do |filter_row|
+        partitions_filtering = QueryBuilders::PartitionsFiltering.new
+        partitions_filtering.with_event_types
+        filter_row = filter_row.to_filter_row if filter_row.is_a?(QueryBuilders::Filters::MarkerFilterRow)
+        partitions_filtering.add_filter_row(filter_row)
+        partitions_filtering.to_sql_builder.unselect.select('context, stream_name, event_type')
+      end
+      final_partition_builder = SQLBuilder.union_builders(partition_builders)
+      expanded_partitions_list = @query_strategy.exec_params(*final_partition_builder.to_exec_params)
+      expanded_partitions_list = expanded_partitions_list.group_by { _1['event_type'] }
+      expanded_filter_rows =
+        to_expand.flat_map do |filter_row|
+          case filter_row
+          when QueryBuilders::Filters::FilterRow
+            filter_row.event_type_filters.flat_map do |event_type_filter|
+              related_partitions =
+                if event_type_filter.prefix?
+                  expanded_partitions_list.select do |event_type, _|
+                    event_type.start_with?(event_type_filter.event_type)
+                  end.values.flatten
+                else
+                  expanded_partitions_list[event_type_filter.event_type]
+                end
+              next [] unless related_partitions
+
+              if filter_row.stream_filter
+                related_partitions = related_partitions.select do |attrs|
+                  if filter_row.stream_filter.context?
+                    attrs['context'] == filter_row.stream_filter.context
+                  else
+                    attrs['context'] == filter_row.stream_filter.context &&
+                      attrs['stream_name'] == filter_row.stream_filter.stream_name
+                  end
+                end
+              end
+              related_partitions.map do |partition_attrs|
+                stream_filter = QueryBuilders::Filters::StreamFilter.new(
+                  context: partition_attrs['context'],
+                  stream_name: partition_attrs['stream_name']
+                )
+                event_type_filter = QueryBuilders::Filters::EventTypeFilter.new(
+                  event_type: partition_attrs['event_type'], prefix: false
+                )
+                QueryBuilders::Filters::FilterRow.new(stream_filter:, event_type_filters: [event_type_filter])
+              end
+            end
+          when QueryBuilders::Filters::MarkerFilterRow
+            related_partitions = expanded_partitions_list[filter_row.marker_filter.event_type]
+            next [] unless related_partitions
+
+            if filter_row.stream_filter
+              related_partitions = related_partitions.select do |attrs|
+                attrs['context'] == filter_row.stream_filter.context
+              end
+            end
+            related_partitions.map do |partition_attrs|
+              stream_filter = QueryBuilders::Filters::StreamFilter.new(
+                context: partition_attrs['context'],
+                stream_name: partition_attrs['stream_name']
+              )
+              QueryBuilders::Filters::MarkerFilterRow.new(stream_filter:, marker_filter: filter_row.marker_filter.dup)
+            end
+          else
+            Utils.missing_implementation!(filter_row)
+          end
+        end
+      adjusted_rows = expanded_filter_rows + rest_filter_rows
+      return [QueryBuilders::Filters::FilterRow.null_filter_row] if adjusted_rows.empty?
+
+      adjusted_rows
+    end
+
+    # @param repr [Symbol, nil]
+    # @return [Array<PgEventstore::EventGlobalIndex>, Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>,
+    #   Array<PgEventstore::EventGlobalIndex::ReadApiRepr>, Array<PgEventstore::EventGlobalIndex::WriteApiRepr>,
+    #   Array<PgEventstore::EventGlobalIndex::RevisionCheckRepr>]
+    def deserialize(pg_result, repr: nil)
+      pg_result.map do |attrs|
+        EventGlobalIndex.create_representation(attrs.transform_keys(&:to_sym), repr:)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/queries/links_resolver.rb

@@ -9,8 +9,10 @@ module PgEventstore
     private :connection
 
     # @param connection [PgEventstore::Connection]
-    def initialize(connection)
+    # @param query_strategy [PgEventstore::QueryStrategy]
+    def initialize(connection, query_strategy)
       @connection = connection
+      @query_strategy = query_strategy
     end
 
     # Takes an array of events, look for link events in there and replaces link events with original events
@@ -20,9 +22,9 @@ module PgEventstore
       link_events = raw_events.select { _1['link_partition_id'] }.group_by { _1['link_partition_id'] }
       return raw_events if link_events.empty?
 
-      original_events = load_original_events(link_events).to_h { |attrs| [attrs['id'], attrs] }
+      original_events = load_original_events(link_events).to_h { |attrs| [attrs['global_position'], attrs] }
       raw_events.map do |attrs|
-        original_event = original_events[attrs['link_id']]
+        original_event = original_events[attrs['link_global_position']]
         next attrs unless original_event
 
         original_event.merge('link' => attrs).merge(attrs.except(*original_event.keys))
@@ -37,15 +39,16 @@ module PgEventstore
       partitions = partition_queries.find_by_ids(link_events.keys)
       sql_builders = partitions.map do |partition|
         sql_builder = SQLBuilder.new.select('*').from(partition['table_name'])
-        sql_builder.where('id  = ANY(?::uuid[])', link_events[partition['id']].map { _1['link_id'] })
+        sql_builder.where(
+          'global_position = ANY(?::bigint[])',
+          link_events[partition['id']].map { _1['link_global_position'] }
+        )
       end
       sql_builder = sql_builders[1..].each_with_object(sql_builders.first) do |builder, top_builder|
         top_builder.union(builder)
       end
 
-      connection.with do |conn|
-        conn.exec_params(*sql_builder.to_exec_params)
-      end.to_a
+      @query_strategy.exec_params(*sql_builder.to_exec_params).to_a
     end
 
     # @return [PgEventstore::PartitionQueries]

data/lib/pg_eventstore/queries/maintenance_queries.rb

@@ -3,6 +3,11 @@
 module PgEventstore
   # @!visibility private
   class MaintenanceQueries
+    # @return [Integer]
+    EVENT_INDEXES_TO_REMOVE_PER_QUERY = 10_000
+    # @return [Integer]
+    EVENT_INDEXES_TO_UPDATE_PER_QUERY = 10_000
+
     # @!attribute connection
     #   @return [PgEventstore::Connection]
     attr_reader :connection
@@ -13,36 +18,155 @@ module PgEventstore
       @connection = connection
     end
 
+    # TODO: refactor me. Reason: fatty
     # @param stream [PgEventstore::Stream]
     # @return [Integer] number of deleted events of the given stream
     def delete_stream(stream)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, stream.deconstruct)
-          DELETE FROM events WHERE context = $1 AND stream_name = $2 AND stream_id = $3
-        SQL
-      end.cmd_tuples
+      total_removed = 0
+      transaction_queries.transaction(:read_committed) do
+        stream_global_idx = streams_global_index_queries.find_by!(stream)
+        streams_global_index_queries.delete(stream_global_idx.id)
+        global_position = 1
+        loop do
+          deleted_events_global_index = connection.with do |conn|
+            conn.exec_params(<<~SQL, [stream_global_idx.id, global_position, EVENT_INDEXES_TO_REMOVE_PER_QUERY]).to_a
+              delete from events_global_index
+                     where global_position in (
+                         select global_position from events_global_index
+                                  where streams_global_index_id = $1 and global_position >= $2
+                                  order by global_position asc
+                                  limit $3
+                     )
+                     returning event_type_partition_id, global_position
+            SQL
+          end
+          break if deleted_events_global_index.empty?
+
+          global_position = deleted_events_global_index.last['global_position'] + 1
+          total_removed += deleted_events_global_index.size
+          deleted_events_global_index = deleted_events_global_index.group_by { _1['event_type_partition_id'] }
+          partitions = partition_queries.find_by_ids(deleted_events_global_index.keys).to_h { [_1['id'], _1] }
+          queries = deleted_events_global_index.map do |partition_id, idxs|
+            partition = partitions[partition_id]
+            positions = idxs.map { _1['global_position'] }.join(', ')
+            context = PG::Connection.escape(partition['context'])
+            stream_name = PG::Connection.escape(partition['stream_name'])
+            event_type = PG::Connection.escape(partition['event_type'])
+            <<~SQL
+              delete from events
+                     where context = '#{context}' and stream_name = '#{stream_name}' and type = '#{event_type}'
+                           and global_position in (#{positions});
+              delete from event_subscription_positions where global_position in (#{positions});
+              delete from event_subscription_positions_unprocessed where global_position in (#{positions});
+              delete from event_markers_index where global_position in (#{positions});
+            SQL
+          end
+          connection.with do |conn|
+            conn.exec(queries.join("\n"))
+          end
+        end
+      end
+      total_removed
     end
 
+    # TODO: refactor me. Reason: fatty
     # @param event [PgEventstore::Event]
-    # @return [Integer] number of deleted events
+    # @return [void]
     def delete_event(event)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [event.stream.context, event.stream.stream_name, event.type, event.global_position])
-          DELETE FROM events WHERE context = $1 AND stream_name = $2 AND type = $3 AND global_position = $4
-        SQL
-      end.cmd_tuples
-    end
+      stream = event.stream
+      transaction_queries.transaction(:read_commited) do
+        stream_global_idx = streams_global_index_queries.find_by!(stream)
+        current_stream_revision = connection.with do |conn|
+          conn.exec_params(
+            'select stream_revision from streams_global_index where id = $1 for update', [stream_global_idx.id]
+          )
+        end.to_a.first['stream_revision']
+        exists =
+          connection.with do |conn|
+            conn.exec_params(<<~SQL, [event.global_position]).first&.[]('one') == 1
+              select 1 as one from events_global_index where global_position = $1
+            SQL
+          end
+        raise RecordNotFound.new('events_global_index', event.global_position) unless exists
+        # We are deleting the only event. Thus, we should delete the whole stream
+        return delete_stream(stream) if current_stream_revision == 0
 
-    # @param stream [PgEventstore::Stream]
-    # @param after_revision [Integer]
-    # @return [void]
-    def adjust_stream_revisions(stream, after_revision)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [stream.context, stream.stream_name, stream.stream_id, after_revision])
-          UPDATE events SET stream_revision = stream_revision - 1
-            WHERE context = $1 AND stream_name = $2
-              AND stream_id = $3 AND stream_revision > $4
-        SQL
+        deleted_event = connection.with do |conn|
+          conn.exec_params(<<~SQL, [stream_global_idx.id, event.global_position]).to_a.first
+            delete from events_global_index where streams_global_index_id = $1 and global_position = $2
+                   returning global_position, event_type_partition_id, stream_revision
+          SQL
+        end
+
+        affected_partition = partition_queries.find_by_ids([deleted_event['event_type_partition_id']]).first
+        connection.with do |conn|
+          delete_args = [
+            affected_partition['context'],
+            affected_partition['stream_name'],
+            affected_partition['event_type'],
+            deleted_event['global_position'],
+          ]
+          conn.exec_params(<<~SQL, delete_args)
+            with _1 as (delete from events where context = $1 and stream_name = $2 and type = $3 and global_position = $4),
+             _2 as (delete from event_subscription_positions where global_position = $4),
+             _3 as (delete from event_subscription_positions_unprocessed where global_position = $4),
+             _4 as (delete from event_markers_index where global_position = $4)
+             select 1;
+          SQL
+        end
+        first_updated_event = nil
+        stream_revision = deleted_event['stream_revision']
+        loop do
+          updated_events = connection.with do |conn|
+            conn.exec_params(<<~SQL, [stream_global_idx.id, stream_revision, EVENT_INDEXES_TO_UPDATE_PER_QUERY]).to_a
+              update event_markers_index set stream_revision = stream_revision - 1
+                     where global_position in (
+                         select global_position from events_global_index
+                                  where streams_global_index_id = $1 and stream_revision > $2
+                                  order by stream_revision asc
+                                  limit $3
+                     )
+            SQL
+            conn.exec_params(<<~SQL, [stream_global_idx.id, stream_revision, EVENT_INDEXES_TO_UPDATE_PER_QUERY]).to_a
+              update events_global_index set stream_revision = stream_revision - 1
+                     where global_position in (
+                         select global_position from events_global_index
+                                  where streams_global_index_id = $1 and stream_revision > $2
+                                  order by stream_revision asc
+                                  limit $3
+                     )
+                     returning event_type_partition_id, global_position, stream_revision
+            SQL
+          end
+          first_updated_event ||= updated_events.min_by { _1['stream_revision'] }
+          break if updated_events.empty?
+
+          stream_revision += updated_events.size
+          updated_events = updated_events.group_by { _1['event_type_partition_id'] }
+          partitions = partition_queries.find_by_ids(updated_events.keys).to_h { [_1['id'], _1] }
+          queries = updated_events.flat_map do |partition_id, idxs|
+            partition = partitions[partition_id]
+            context = PG::Connection.escape(partition['context'])
+            stream_name = PG::Connection.escape(partition['stream_name'])
+            event_type = PG::Connection.escape(partition['event_type'])
+            idxs.map do |idx|
+              <<~SQL
+                update events set stream_revision = #{idx['stream_revision']}
+                  where context = '#{context}' and stream_name = '#{stream_name}' and type = '#{event_type}' and
+                        global_position = #{idx['global_position']};
+              SQL
+            end
+          end
+          connection.with do |conn|
+            conn.exec(queries.join("\n"))
+          end
+        end
+        stream_idx_attrs_to_update = { stream_revision: current_stream_revision - 1 }
+        # Adjust starting_position in case zero revision event was deleted
+        if deleted_event['stream_revision'] == 0
+          stream_idx_attrs_to_update[:starting_position] = first_updated_event['global_position']
+        end
+        streams_global_index_queries.update(stream_global_idx.id, **stream_idx_attrs_to_update)
       end
     end
 
@@ -50,32 +174,25 @@ module PgEventstore
     # @param after_revision [Integer]
     # @return [Integer]
     def events_to_lock_count(stream, after_revision)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [*stream.deconstruct, after_revision])
-          EXPLAIN SELECT * FROM events
-                    WHERE context = $1 AND stream_name = $2 AND stream_id = $3 AND stream_revision > $4
-        SQL
-      end.to_a.first['QUERY PLAN'].match(/rows=(\d+)/)[1].to_i
+      stream_index = streams_global_index_queries.find_by!(stream)
+      stream_index.stream_revision - after_revision
     end
 
-    # @param event [PgEventstore::Event]
-    # @return [PgEventstore::Event]
-    def reload_event(event)
-      event_attrs = connection.with do |conn|
-        conn.exec_params(<<~SQL, [event.stream&.context, event.stream&.stream_name, event.type, event.global_position])
-          SELECT * FROM events WHERE context = $1 AND stream_name = $2 AND type = $3 AND global_position = $4 LIMIT 1
-        SQL
-      end.to_a.first
-      return unless event_attrs
+    private
 
-      basic_deserializer.deserialize(event_attrs)
+    # @return [PgEventstore::StreamsGlobalIndexQueries]
+    def streams_global_index_queries
+      StreamsGlobalIndexQueries.new(connection, QueryStrategy::Foreground.new(connection))
     end
 
-    private
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
 
-    # @return [PgEventstore::EventDeserializer]
-    def basic_deserializer
-      EventDeserializer.new([], ->(_event_type) { Event })
+    # @return [PgEventstore::PartitionQueries]
+    def partition_queries
+      PartitionQueries.new(connection)
     end
   end
 end