pg_eventstore 2.0.0 → 3.0.0

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
@@ -46,9 +48,7 @@ module PgEventstore
         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

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:,
-        table_name: event_type_partition_name(stream, 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)