pg_eventstore 1.13.4 → 3.0.0

data/lib/pg_eventstore/queries/partition_queries.rb

@@ -9,8 +9,9 @@ module PgEventstore
     private :connection
 
     # @param connection [PgEventstore::Connection]
-    def initialize(connection)
+    def initialize(connection, query_strategy = QueryStrategy::Foreground.new(connection))
       @connection = connection
+      @query_strategy = query_strategy
     end
 
     # @param stream [PgEventstore::Stream]
@@ -28,24 +29,18 @@ module PgEventstore
         INSERT INTO partitions (#{attributes.keys.join(', ')})
           VALUES (#{Utils.positional_vars(attributes.values)}) RETURNING *
       SQL
-      partition = connection.with do |conn|
+      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]
+    # @param context_partition_id [Integer]
     # @return [Hash] partition attributes
-    def create_stream_name_partition(stream, context_partition_name)
+    def create_stream_name_partition(stream, context_partition_id)
       attributes = {
-        context: stream.context, stream_name: stream.stream_name, table_name: stream_name_partition_name(stream)
+        context: stream.context, stream_name: stream.stream_name, table_name: stream_name_partition_name(stream),
+        parent_context_partition_id: context_partition_id
       }
 
       loop do
@@ -58,26 +53,22 @@ module PgEventstore
         INSERT INTO partitions (#{attributes.keys.join(', ')})
           VALUES (#{Utils.positional_vars(attributes.values)}) RETURNING *
       SQL
-      partition = connection.with do |conn|
+      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 event_type [String]
-    # @param stream_name_partition_name [String]
+    # @param context_partition_id [Integer]
+    # @param stream_name_partition_id [Integer]
     # @return [Hash] partition attributes
-    def create_event_type_partition(stream, event_type, stream_name_partition_name)
+    def create_event_type_partition(stream, event_type, context_partition_id,
+                                    stream_name_partition_id)
       attributes = {
-        context: stream.context, stream_name: stream.stream_name, event_type: event_type,
-        table_name: event_type_partition_name(stream, event_type)
+        context: stream.context, stream_name: stream.stream_name, event_type:,
+        table_name: event_type_partition_name(stream, event_type), parent_context_partition_id: context_partition_id,
+        parent_stream_name_partition_id: stream_name_partition_id
       }
 
       loop do
@@ -90,16 +81,9 @@ module PgEventstore
         INSERT INTO partitions (#{attributes.keys.join(', ')})
           VALUES (#{Utils.positional_vars(attributes.values)}) RETURNING *
       SQL
-      partition = connection.with do |conn|
+      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]
@@ -117,9 +101,15 @@ module PgEventstore
 
       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'])
+        stream_name_partition(stream) ||
+        create_stream_name_partition(stream, context_partition['id'])
 
-      create_event_type_partition(stream, event_type, stream_name_partition['table_name'])
+      create_event_type_partition(
+        stream,
+        event_type,
+        context_partition['id'],
+        stream_name_partition['id']
+      )
     end
 
     # @param stream [PgEventstore::Stream]
@@ -171,47 +161,15 @@ module PgEventstore
     # @param ids [Array<Integer>]
     # @return [Array<Hash>]
     def find_by_ids(ids)
-      connection.with do |conn|
-        conn.exec_params('select * from partitions where id = ANY($1::bigint[])', [ids])
-      end.to_a
+      @query_strategy.exec_params('select * from partitions where id = ANY($1::bigint[])', [ids]).to_a
     end
 
-    # @param stream_filters [Array<Hash[Symbol, String]>]
-    # @param event_filters [Array<String>]
+    # @param filters_collection [PgEventstore::QueryBuilders::Filters::Collection]
     # @param scope [Symbol] what kind of partition we want to receive. Available options are :event_type, :context,
     #   :stream_name and :auto. In :auto mode the scope will be calculated based on stream_filters and event_filters.
     # @return [Array<PgEventstore::Partition>]
-    def partitions(stream_filters, event_filters, scope: :event_type)
-      stream_filters = stream_filters.select { QueryBuilders::PartitionsFiltering.correct_stream_filter?(_1) }
-      sql_builder =
-        if event_filters.any?
-          # When event type filters are present - they apply constraints to any stream filter. Thus, we can't look up
-          # partitions by stream attributes separately.
-          filter = QueryBuilders::PartitionsFiltering.new
-          stream_filters.each { |attrs| filter.add_stream_attrs(**attrs) }
-          filter.add_event_types(event_filters)
-          set_partitions_scope(filter, stream_filters, event_filters, scope)
-        else
-          # When event type filters are absent - we can look up partitions by context and context/stream_name
-          # separately, thus potentially producing one-to-one mapping of filter-to-partition with :auto scope. For
-          # example, let's say we have stream attributes filter like
-          # [{ context: 'FooCtx', stream_name: 'Bar'}, { context: 'BarCtx' }], then we would be able to look up
-          # partitions by the exact match, returning only two of them according to the provided filters - stream
-          # partition for first filter and context partition for second filter.
-          builders = stream_filters.map do |attrs|
-            filter = QueryBuilders::PartitionsFiltering.new
-            filter.add_stream_attrs(**attrs)
-            set_partitions_scope(filter, [attrs], event_filters, scope)
-          end
-
-          sql_builder = SQLBuilder.union_builders(builders) if builders.any?
-          sql_builder ||
-            begin
-              builder = QueryBuilders::PartitionsFiltering.new
-              set_partitions_scope(builder, stream_filters, event_filters, scope)
-            end
-        end
-
+    def partitions(filters_collection, scope: :event_type)
+      sql_builder = QueryBuilders::PartitionsFiltering.assemble_sql_builder(filters_collection, scope:)
       connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end.map(&method(:deserialize))
@@ -236,45 +194,29 @@ module PgEventstore
       "event_types_#{Digest::MD5.hexdigest("#{stream.context}-#{stream.stream_name}-#{event_type}")[0..5]}"
     end
 
-    private
+    # @param partition [PgEventstore::Partition]
+    # @return [void]
+    def detach_event_type_partition(partition)
+      parent = deserialize(find_by_ids([partition.parent_stream_name_partition_id]).first)
+      connection.with do |conn|
+        conn.exec("alter table #{parent.table_name} detach partition #{partition.table_name}")
+      end
+    end
 
-    # @param partitions_filter [PgEventstore::QueryBuilders::PartitionsFiltering]
-    # @param stream_filters [Array<Hash[Symbol, String]>]
-    # @param event_filters [Array<String>]
-    # @param scope [Symbol]
-    # @return [PgEventstore::SQLBuilder]
-    def set_partitions_scope(partitions_filter, stream_filters, event_filters, scope)
-      case scope
-      when :event_type
-        partitions_filter.with_event_types
-      when :stream_name
-        filter = QueryBuilders::PartitionsFiltering.new
-        filter.without_event_types
-        filter.with_stream_names
-        builder = filter.to_sql_builder
-        builder.where(
-          '(context, stream_name) in ?',
-          partitions_filter.to_sql_builder.unselect.select('context, stream_name').group('context, stream_name')
+    # @param partition [PgEventstore::Partition]
+    # @return [void]
+    def attach_event_type_partition(partition)
+      parent = deserialize(find_by_ids([partition.parent_stream_name_partition_id]).first)
+      connection.with do |conn|
+        event_type = conn.escape_string(partition.event_type)
+        conn.exec(
+          "alter table #{parent.table_name} attach partition #{partition.table_name} for values in ('#{event_type}')"
         )
-      when :context
-        filter = QueryBuilders::PartitionsFiltering.new
-        filter.without_event_types
-        filter.without_stream_names
-        builder = filter.to_sql_builder
-        builder.where('context in ?', partitions_filter.to_sql_builder.unselect.select('context').group('context'))
-      when :auto
-        if event_filters.any?
-          set_partitions_scope(partitions_filter, stream_filters, event_filters, :event_type)
-        elsif stream_filters.any? { _1[:stream_name] }
-          set_partitions_scope(partitions_filter, stream_filters, event_filters, :stream_name)
-        else
-          set_partitions_scope(partitions_filter, stream_filters, event_filters, :context)
-        end
-      else
-        raise NotImplementedError, "Don't know how to handle #{scope.inspect} scope!"
       end
     end
 
+    private
+
     # @param attrs [Hash]
     # @return [PgEventstore::Partition]
     def deserialize(attrs)

data/lib/pg_eventstore/queries/replica_queries.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class ReplicaQueries
+    MAX_PARTITIONS_TO_RESOLVE_PER_CALL = 100
+
+    # @!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 indexes [Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>]
+    # @return [Array<Integer>]
+    def load_subscription_positions(indexes)
+      params = [indexes.first.subscription_position, indexes.last.subscription_position]
+      exists = @query_strategy.exec_params(<<~SQL, params).first&.[]('one')
+        select 1 as one from event_subscription_positions where subscription_position between $1 and $2 limit 1
+      SQL
+      return [] unless exists
+
+      @query_strategy.exec_params(<<~SQL, [indexes.map(&:subscription_position)]).map { _1['subscription_position'] }
+        select subscription_position from event_subscription_positions where subscription_position = any($1::bigint[])
+      SQL
+    end
+
+    # @param indexes [Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>]
+    # @return [Array<PgEventstore::RawEvent>]
+    def load_events(indexes)
+      indexes = indexes.dup
+      raw_events = []
+      loop do
+        range = Utils.range_to_slice(indexes.map(&:event_type_partition_id), MAX_PARTITIONS_TO_RESOLVE_PER_CALL)
+        indexes_to_resolve = indexes.slice!(range)
+        break if indexes_to_resolve.empty?
+
+        raw_events.push(*events_global_index_queries.resolve_indexes(indexes_to_resolve, resolve_link_tos: false))
+      end
+      raw_events.map { RawEvent.new(**_1.transform_keys(&:to_sym)) }
+    end
+
+    # @param indexes [Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>]
+    # @return [Array<PgEventstore::EventGlobalIndex>]
+    def load_events_global_index(indexes)
+      result = @query_strategy.exec_params(<<~SQL, [indexes.map(&:global_position)])
+        select * from events_global_index where global_position = any($1::bigint[])
+      SQL
+      result.map { EventGlobalIndex.new(**_1.transform_keys(&:to_sym)) }
+    end
+
+    # @param indexes [Array<PgEventstore::EventGlobalIndex>]
+    # @return [Array<PgEventstore::StreamGlobalIndex>]
+    def load_streams_global_index(indexes)
+      result = @query_strategy.exec_params(<<~SQL, [indexes.map(&:streams_global_index_id)])
+        select * from streams_global_index where id = any($1::bigint[])
+      SQL
+      stream_revisions_map = indexes.group_by(&:streams_global_index_id).to_h do |stream_id, events_idx|
+        [stream_id, events_idx.max_by(&:stream_revision).stream_revision]
+      end
+      result.map do |attrs|
+        attrs = attrs.transform_keys(&:to_sym)
+        attrs[:stream_revision] = stream_revisions_map[attrs[:id]]
+        StreamGlobalIndex.new(**attrs)
+      end
+    end
+
+    # @param indexes [Array<PgEventstore::EventGlobalIndex::SubscriptionRepr>]
+    # @return [Array<PgEventstore::EventMarkerIndex>]
+    def load_event_markers_index(indexes)
+      result = @query_strategy.exec_params(<<~SQL, [indexes.map(&:global_position)])
+        select * from event_markers_index where global_position = any($1::bigint[])
+      SQL
+      result.map { EventMarkerIndex.new(**_1.transform_keys(&:to_sym)) }
+    end
+
+    # @param indexes [Array<PgEventstore::EventMarkerIndex>]
+    # @return [Array<PgEventstore::EventMarker>]
+    def load_markers(indexes)
+      result = @query_strategy.exec_params(<<~SQL, [indexes.map(&:marker_id).uniq])
+        select * from event_markers where id = any($1::bigint[])
+      SQL
+      result.map { EventMarker.new(**_1.transform_keys(&:to_sym)) }
+    end
+
+    # @param indexes [Array<PgEventstore::EventGlobalIndex>]
+    # @return [Array<PgEventstore::Partition>]
+    def load_partitions(indexes)
+      ids = indexes.map(&:context_partition_id).uniq + indexes.map(&:stream_name_partition_id).uniq +
+            indexes.map(&:event_type_partition_id).uniq
+      result = @query_strategy.exec_params(<<~SQL, [ids])
+        select * from partitions where id = any($1::bigint[]) order by id
+      SQL
+      result.map { Partition.new(**_1.transform_keys(&:to_sym)) }
+    end
+
+    private
+
+    # @return [PgEventstore::EventsGlobalIndexQueries]
+    def events_global_index_queries
+      EventsGlobalIndexQueries.new(connection, @query_strategy)
+    end
+  end
+end

data/lib/pg_eventstore/queries/streams_global_index_queries.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class StreamsGlobalIndexQueries
+    # @!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]
+    # @return [PgEventstore::StreamGlobalIndex]
+    def find_or_create_by(stream)
+      transaction_queries.transaction do
+        find_by(stream) || create(stream)
+      end
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::StreamGlobalIndex, nil]
+    def find_by(stream)
+      idx_partitions_filter = QueryBuilders::Filters::Collection.from_options({ filter: { streams: [stream.to_hash] } })
+      filtering = QueryBuilders::StreamsGlobalIndexFiltering.new
+      idx_partitions_filter.collection.each(&filtering.method(:add_filter_row))
+      deserialize_one(@query_strategy.exec_params(*filtering.to_exec_params))
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::StreamGlobalIndex]
+    def find_by!(stream)
+      find_by(stream) ||
+        raise(RecordNotFound.new(QueryBuilders::StreamsGlobalIndexFiltering::PRIMARY_TABLE_NAME, stream))
+    end
+
+    # @param id [Integer]
+    # @param attrs [Hash]
+    # @return [void]
+    def update(id, **attrs)
+      attrs_sql = attrs.keys.map.with_index(2) do |attr, index|
+        "#{attr} = $#{index}"
+      end.join(', ')
+      @query_strategy.exec_params(<<~SQL, [id, *attrs.values])
+        UPDATE streams_global_index SET #{attrs_sql} WHERE id = $1
+      SQL
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::StreamGlobalIndex]
+    def create(stream)
+      filter_collection = QueryBuilders::Filters::Collection.from_options(
+        { filter: { streams: [{ context: stream.context, stream_name: stream.stream_name }] } }
+      )
+      partitions_sql_builder = QueryBuilders::PartitionsFiltering.assemble_sql_builder(
+        filter_collection,
+        scope: :stream_name
+      )
+      partitions_sql_builder.unselect.select('id')
+      sql, positional_args = partitions_sql_builder.to_exec_params
+      stream_revision = Stream::NON_EXISTING_STREAM_REVISION
+      starting_position = StreamGlobalIndex::INITIAL_STARTING_POSITION
+      stream_id = PG::Connection.escape(stream.stream_id)
+      value = "((#{sql}), '#{stream_id}', #{stream_revision}, #{starting_position})"
+
+      res = @query_strategy.exec_params(<<~SQL, positional_args)
+        INSERT INTO streams_global_index ("partition_id", "stream_id", "stream_revision", "starting_position")
+        VALUES #{value} RETURNING *
+      SQL
+      deserialize_one(res)
+    end
+
+    # @param id [Integer]
+    # @return [Boolean]
+    def delete(id)
+      res = @query_strategy.exec_params('delete from streams_global_index where id = $1', [id])
+      res.cmd_tuples == 1
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [Boolean]
+    def stream_exists?(stream)
+      idx_partitions_filter = QueryBuilders::Filters::Collection.from_options({ filter: { streams: [stream.to_hash] } })
+      filtering = QueryBuilders::StreamsGlobalIndexFiltering.new
+      idx_partitions_filter.collection.each(&filtering.method(:add_filter_row))
+      builder = filtering.to_sql_builder.unselect.select('1 as exists')
+      @query_strategy.exec_params(*builder.to_exec_params).ntuples == 1
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [Integer, nil]
+    def stream_revision(stream)
+      idx_partitions_filter = QueryBuilders::Filters::Collection.from_options({ filter: { streams: [stream.to_hash] } })
+      filtering = QueryBuilders::StreamsGlobalIndexFiltering.new
+      idx_partitions_filter.collection.each(&filtering.method(:add_filter_row))
+      builder = filtering.to_sql_builder.unselect.select('stream_revision')
+      @query_strategy.exec_params(*builder.to_exec_params).first&.dig('stream_revision')
+    end
+
+    # @param options [Hash]
+    # @option options [Integer, nil] :from_position
+    # @option options [Integer, nil] :max_count
+    # @option options [String, Symbol, nil] :direction
+    # @return [Array<PgEventstore::StreamGlobalIndex>]
+    def streams_global_index(options)
+      sql_builder = QueryBuilders::StreamsGlobalIndexFiltering.sql_builder_for_basic_pagination(options)
+      deserialize_many(@query_strategy.exec_params(*sql_builder.to_exec_params))
+    end
+
+    # @param indexes [Array<PgEventstore::StreamGlobalIndex>]
+    # @return [Array<PgEventstore::Stream>]
+    def resolve_indexes(indexes)
+      return [] if indexes.empty?
+
+      partition_ids = indexes.map(&:partition_id).uniq
+      partitions = partition_queries.find_by_ids(partition_ids).to_h { [_1['id'], _1] }
+      indexes.map do |stream_global_index|
+        partition = partitions[stream_global_index.partition_id]
+        Stream.new(
+          context: partition['context'],
+          stream_name: partition['stream_name'],
+          stream_id: stream_global_index.stream_id,
+          stream_revision: stream_global_index.stream_revision,
+          starting_position: stream_global_index.starting_position
+        )
+      end
+    end
+
+    private
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
+
+    # @param pg_result [PG::Result]
+    # @return [PgEventstore::StreamGlobalIndex, nil]
+    def deserialize_one(pg_result)
+      first_result = pg_result.first
+      return unless first_result
+
+      StreamGlobalIndex.new(**first_result.transform_keys(&:to_sym))
+    end
+
+    # @param pg_result [PG::Result]
+    # @return [Array<PgEventstore::StreamGlobalIndex>]
+    def deserialize_many(pg_result)
+      pg_result.map do |attrs|
+        StreamGlobalIndex.new(**attrs.transform_keys(&:to_sym))
+      end
+    end
+
+    # @return [PgEventstore::PartitionQueries]
+    def partition_queries
+      PartitionQueries.new(connection)
+    end
+  end
+end

data/lib/pg_eventstore/queries/transaction_queries.rb

@@ -11,6 +11,8 @@ module PgEventstore
     }.tap do |h|
       h.default = h[:serializable]
     end.freeze
+    # @return [Integer]
+    MAX_NUMBER_OF_UNIQUE_CONSTRAINTS_ERROR_RETRIES = 5
 
     # @!attribute connection
     #   @return [PgEventstore::Connection]
@@ -23,39 +25,85 @@ module PgEventstore
     end
 
     # @param level [Symbol] transaction isolation level
+    # @param read_only [Boolean] whether transaction is read-only
     # @return [void]
-    def transaction(level = :serializable, &blk)
+    def transaction(level = :serializable, read_only: false, &blk)
       connection.with do |conn|
         # We are inside a transaction already - no need to start another one
         next yield if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
 
-        pg_transaction(ISOLATION_LEVELS[level], conn, &blk)
+        pg_transaction(ISOLATION_LEVELS[level], read_only, conn, &blk)
       end
     end
 
     private
 
     # @param level [String] PostgreSQL transaction isolation level
+    # @param read_only [Boolean]
     # @param pg_connection [PG::Connection]
     # @return [void]
-    def pg_transaction(level, pg_connection, &_blk)
-      pg_connection.transaction do
-        pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
-        yield
+    def pg_transaction(level, read_only, pg_connection, &)
+      retries_count = 0
+      begin
+        _transaction(pg_connection) do
+          if read_only
+            pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level} READ ONLY")
+          else
+            pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
+          end
+          yield
+        end
+      rescue PG::TRSerializationFailure, PG::TRDeadlockDetected
+        retry
+      rescue PG::UniqueViolation
+        retries_count += 1
+        raise if retries_count >= MAX_NUMBER_OF_UNIQUE_CONSTRAINTS_ERROR_RETRIES
+
+        retry
       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
 
+    # TODO: next pg gem release (presumably v1.6.4) should already include the fix of PG::Connection#transaction.
+    #       Changes are already in master branch
+    #       https://github.com/ged/ruby-pg/commit/c3d2aabd0a19d20bb1f2b2fa2e5b30f03b043aff
+    #       Once it is released - change pg gem requirement in gemspec to '>= 1.6.4' and remove this implementation.
+    # @param conn [PG::Connection]
+    # rubocop:disable Lint/RescueException
+    def _transaction(conn)
+      rollback = false
+      conn.exec('BEGIN')
+      yield
+    rescue PG::RollbackTransaction
+      rollback = true
+      perform_rollback(conn)
+    rescue Exception
+      rollback = true
+      perform_rollback(conn)
+      raise
+    ensure
+      unless rollback
+        if Thread.current.status == 'aborting'
+          perform_rollback(conn)
+        else
+          conn.exec('COMMIT')
+        end
+      end
+    end
+    # rubocop:enable Lint/RescueException
+
+    def perform_rollback(conn)
+      conn.cancel if conn.transaction_status == PG::PQTRANS_ACTIVE
+      conn.block
+      conn.exec('ROLLBACK')
+    end
+
     # @return [PgEventstore::PartitionQueries]
     def partition_queries
       PartitionQueries.new(connection)

data/lib/pg_eventstore/queries.rb

@@ -1,14 +1,28 @@
 # frozen_string_literal: true
 
 require_relative 'sql_builder'
+require_relative 'query_builders/filters/collection'
+require_relative 'query_builders/read_cursor/stream_cursor'
 require_relative 'query_builders/basic_filtering'
+require_relative 'query_builders/subscription_events_filtering'
 require_relative 'query_builders/events_filtering'
 require_relative 'query_builders/partitions_filtering'
+require_relative 'query_builders/events_global_index_filtering'
+require_relative 'query_builders/streams_global_index_filtering'
+require_relative 'query_builders/event_subscription_positions_filtering'
+require_relative 'query_builders/event_markers_filtering'
+require_relative 'query_builders/event_markers_index_filtering'
+require_relative 'query_builders/index_based_events_filtering'
 require_relative 'queries/transaction_queries'
 require_relative 'queries/event_queries'
 require_relative 'queries/partition_queries'
 require_relative 'queries/links_resolver'
 require_relative 'queries/maintenance_queries'
+require_relative 'queries/events_global_index_queries'
+require_relative 'queries/streams_global_index_queries'
+require_relative 'queries/event_marker_queries'
+require_relative 'queries/index_filtering_queries'
+require_relative 'queries/replica_queries'
 
 module PgEventstore
   # @!visibility private
@@ -24,9 +38,23 @@ module PgEventstore
     # @!attribute transactions
     #   @return [PgEventstore::TransactionQueries, nil]
     attribute(:transactions)
-
     # @!attribute maintenance
     #   @return [PgEventstore::MaintenanceQueries, nil]
     attribute(:maintenance)
+    # @!attribute maintenance
+    #   @return [PgEventstore::EventsGlobalIndexQueries, nil]
+    attribute(:events_global_index)
+    # @!attribute maintenance
+    #   @return [PgEventstore::StreamsGlobalIndexQueries, nil]
+    attribute(:streams_global_index)
+    # @!attribute event_subscription_positions
+    #   @return [PgEventstore::EventSubscriptionPositionQueries, nil]
+    attribute(:event_subscription_positions)
+    # @!attribute event_subscription_positions
+    #   @return [PgEventstore::EventMarkerQueries, nil]
+    attribute(:event_markers)
+    # @!attribute event_subscription_positions
+    #   @return [PgEventstore::IndexFilteringQueries, nil]
+    attribute(:index_filtering)
   end
 end