pg_eventstore 2.0.0 → 3.0.0

data/lib/pg_eventstore/web/application.rb

@@ -32,7 +32,7 @@ module PgEventstore
         # @return [Array<Hash>, nil]
         # rubocop:disable Style/HashConversion
         def streams_filter
-          streams = QueryBuilders::EventsFiltering.extract_streams_filter(params)
+          streams = extract_streams_filter(params)
           streams = streams.select { _1 in { context: String, stream_name: String, stream_id: String } }
           streams = streams.map do |stream_attrs|
             Hash[stream_attrs.reject { |_, value| value == '' }].transform_keys(&:to_sym)
@@ -41,17 +41,32 @@ module PgEventstore
         end
         # rubocop:enable Style/HashConversion
 
-        # @return [String, nil]
-        def system_stream
-          params in { filter: { system_stream: String => system_stream } }
-          system_stream if Stream::KNOWN_SYSTEM_STREAMS.include?(system_stream)
-        end
-
-        # @return [Array<String>, nil]
+        # @return [Array<String, Hash>]
         def events_filter
           event_filters = { filter: { event_types: params.dig(:filter, :events) } }
-          events = QueryBuilders::EventsFiltering.extract_event_types_filter(event_filters)
-          events.reject { _1 == '' }
+          event_types = extract_event_types_filter(event_filters)
+          event_types.map do |filter|
+            case filter
+            when String
+              next if filter == ''
+            when Hash
+              next if filter[:type] == ''
+
+              filter[:markers] = normalize_markers(filter)
+            else
+              next
+            end
+
+            filter
+          end.compact
+        end
+
+        # @return [Array<String>]
+        def markers_filter
+          params in { filter: Hash => filter }
+          return [] unless filter
+
+          normalize_markers(filter)
         end
 
         # @return [Symbol]
@@ -137,13 +152,55 @@ module PgEventstore
         def unescape_empty_string(string)
           string == EMPTY_STRING_SIGN ? '' : string
         end
+
+        # @param options [Hash]
+        # @return [Array<String, Hash>]
+        def extract_event_types_filter(options)
+          options in { filter: { event_types: Array => event_types } }
+          event_types = event_types&.select do |event_type|
+            event_type.is_a?(String) || (event_type in { type: String })
+          end
+          event_types || []
+        end
+
+        # @param options [Hash]
+        # @return [Array<Hash[Symbol, String]>]
+        def extract_streams_filter(options)
+          options in { filter: { streams: Array => streams } }
+          streams = streams&.map do |stream_attrs|
+            stream_attrs in { context: String | NilClass => context }
+            stream_attrs in { stream_name: String | NilClass => stream_name }
+            stream_attrs in { stream_id: String | NilClass => stream_id }
+            { context:, stream_name:, stream_id: }
+          end
+          streams || []
+        end
+
+        private
+
+        # @param hash [Hash]
+        # @return [Array<String>]
+        def normalize_markers(hash)
+          hash in { markers: Array => markers }
+          markers ||= []
+          markers.grep(String).reject { _1 == '' }
+        end
       end
 
       get '/' do
         streams_filter = self.streams_filter&.map do |attrs|
           attrs.transform_values { unescape_empty_string(_1) }
         end
-        events_filter = self.events_filter&.map(&method(:unescape_empty_string))
+        events_filter = self.events_filter.map do |event_type|
+          next unescape_empty_string(event_type) if event_type.is_a?(String)
+
+          event_type[:type] = unescape_empty_string(event_type[:type])
+          event_type[:markers] = event_type[:markers]&.grep(String) || []
+          event_type
+        end
+        markers_filter = self.markers_filter.map(&method(:unescape_empty_string))
+        events_filter.push({ markers: markers_filter }) if markers_filter.any?
+
         @collection = Paginator::EventsCollection.new(
           current_config,
           starting_id: params[:starting_id]&.to_i,
@@ -152,14 +209,20 @@ module PgEventstore
           options: {
             filter: { event_types: events_filter, streams: streams_filter },
             resolve_link_tos: resolve_link_tos?,
-          },
-          system_stream:
+          }
         )
+        @gp_to_sp_map = EventSubscriptionPositionQueries.new(
+          PgEventstore.connection(current_config)
+        ).subscription_positions_from_db(@collection.collection)
 
         if request.xhr?
           content_type 'application/json'
           halt 200, {
-            events: erb(:'home/partials/events', { layout: false }, { events: @collection.collection }),
+            events: erb(
+              :'home/partials/events',
+              { layout: false },
+              { events: @collection.collection, gp_to_sp_map: @gp_to_sp_map }
+            ),
             total_count: total_count(@collection.total_count),
             pagination: erb(:'home/partials/pagination_links', { layout: false }, { collection: @collection }),
           }.to_json
@@ -168,6 +231,16 @@ module PgEventstore
         end
       end
 
+      get '/streams' do
+        @collection = Paginator::StreamsCollection.new(
+          current_config,
+          starting_id: params[:starting_id]&.to_i,
+          per_page: Paginator::StreamsCollection::PER_PAGE[params[:per_page]],
+          order: Paginator::StreamsCollection::SQL_DIRECTIONS[params[:order]]
+        )
+        erb :'streams/index'
+      end
+
       get '/subscriptions' do
         @set_collection = Subscriptions::SetCollection.new(connection)
         @current_set = params[:set_name] || @set_collection.names.first
@@ -247,6 +320,17 @@ module PgEventstore
         paginated_json_response(collection)
       end
 
+      get '/markers_filtering', provides: :json do
+        collection = Paginator::MarkersCollection.new(
+          current_config,
+          starting_id: unescape_empty_string(params[:starting_id]),
+          per_page: Paginator::MarkersCollection::PER_PAGE,
+          order: :asc,
+          options: { query: params[:term] }
+        )
+        paginated_json_response(collection)
+      end
+
       post '/subscription_cmd/:set_id/:id/:cmd' do
         validate_subscription_cmd(params[:cmd])
         cmd_class = SubscriptionRunnerCommands.command_class(params[:cmd])
@@ -279,14 +363,14 @@ module PgEventstore
       end
 
       post '/delete_subscription/:id' do
-        SubscriptionQueries.new(connection).delete(Integer(params[:id]))
+        SubscriptionQueries.new(connection, QueryStrategy::Foreground.new(connection)).delete(Integer(params[:id]))
 
         redirect redirect_back_url(fallback_url: url('/subscriptions'))
       end
 
       post '/delete_all_subscriptions' do
         params[:ids].each do |id|
-          SubscriptionQueries.new(connection).delete(Integer(id))
+          SubscriptionQueries.new(connection, QueryStrategy::Foreground.new(connection)).delete(Integer(id))
         end
 
         redirect redirect_back_url(fallback_url: url('/subscriptions'))

data/lib/pg_eventstore/web/paginator/base_collection.rb

@@ -4,6 +4,9 @@ module PgEventstore
   module Web
     module Paginator
       class BaseCollection
+        # This is the minimum amount of symbols requeried to perform search using trigrams gin index
+        MIN_QUERY_SIZE_FOR_ADVANCE_SEARCH = 3
+
         # @!attribute config_name
         #   @return [Symbol]
         attr_reader :config_name
@@ -30,7 +33,8 @@ module PgEventstore
           @starting_id = starting_id
           @per_page = per_page
           @order = order
-          @options = options
+          @options =
+            options.is_a?(Sinatra::IndifferentHash) ? Utils.deep_transform_keys(Hash[options], &:to_sym) : options
         end
 
         # @return [Array]

data/lib/pg_eventstore/web/paginator/event_types_collection.rb

@@ -12,9 +12,9 @@ module PgEventstore
           @collection ||=
             begin
               sql_builder = SQLBuilder.new.select('event_type').from('partitions')
-              sql_builder.where('context is not null and stream_name is not null')
+              sql_builder.where('event_type is not null')
               sql_builder.where("event_type #{direction_operator} ?", starting_id) if starting_id
-              sql_builder.where('event_type ilike ?', "%#{options[:query]}%")
+              compute_event_type_filter(sql_builder)
               sql_builder.group('event_type').order("event_type #{order}").limit(per_page)
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
@@ -28,9 +28,8 @@ module PgEventstore
 
           starting_id = collection.first['event_type']
           sql_builder = SQLBuilder.new.select('event_type').from('partitions')
-          sql_builder.where('context is not null and stream_name is not null')
           sql_builder.where("event_type #{direction_operator} ?", starting_id)
-          sql_builder.where('event_type ilike ?', "%#{options[:query]}%")
+          compute_event_type_filter(sql_builder)
           sql_builder.group('event_type').order("event_type #{order}").limit(1).offset(per_page)
 
           connection.with do |conn|
@@ -44,6 +43,17 @@ module PgEventstore
         def direction_operator
           order == :asc ? '>=' : '<='
         end
+
+        # @param builder [PgEventstore::SQLBuilder]
+        # @return [void]
+        def compute_event_type_filter(builder)
+          query = options[:query].to_s
+          if query.size < MIN_QUERY_SIZE_FOR_ADVANCE_SEARCH
+            builder.where('event_type like ?', "#{query}%")
+          else
+            builder.where('event_type ilike ?', "%#{query}%")
+          end
+        end
       end
     end
   end

data/lib/pg_eventstore/web/paginator/events_collection.rb

@@ -19,57 +19,46 @@ module PgEventstore
         #   count instead because of the potential performance degradation.
         MAX_NUMBER_TO_COUNT = 10_000
 
-        # @param config_name [Symbol]
-        # @param starting_id [String, Integer, nil]
-        # @param per_page [Integer]
-        # @param order [Symbol] :asc or :desc
-        # @param options [Hash] additional options to filter the collection
-        # @param system_stream [String, nil] a name of system stream
-        def initialize(config_name, starting_id:, per_page:, order:, options: {}, system_stream: nil)
-          super(config_name, starting_id:, per_page:, order:, options:)
-          @stream = system_stream ? PgEventstore::Stream.system_stream(system_stream) : PgEventstore::Stream.all_stream
-        end
-
         # @return [Array<PgEventstore::Event>]
         def collection
-          @collection ||= PgEventstore.client(config_name).read(
-            @stream,
-            options: options.merge(from_position: starting_id, max_count: per_page, direction: order)
-          )
+          _collection[0...per_page]
         end
 
         # @return [Integer, nil]
         def next_page_starting_id
           return unless collection.size == per_page
 
-          from_position = event_global_position(collection.first)
-          sql_builder = QueryBuilders::EventsFiltering.events_filtering(
-            @stream,
-            options.merge(from_position:, max_count: 1, direction: order)
-          ).to_sql_builder.unselect.select('global_position').offset(per_page)
-          global_position(sql_builder)
+          event_global_position(_collection[per_page])
         end
 
         # @return [Integer, nil]
         def prev_page_starting_id
-          from_position = event_global_position(collection.first) || starting_id
-          sql_builder = QueryBuilders::EventsFiltering.events_filtering(
-            @stream,
-            options.merge(from_position:, max_count: per_page, direction: order == :asc ? :desc : :asc)
-          ).to_sql_builder.unselect.select('global_position').offset(1)
-          sql, params = sql_builder.to_exec_params
-          sql = "SELECT * FROM (#{sql}) #{Event::PRIMARY_TABLE_NAME} ORDER BY global_position #{order} LIMIT 1"
-          connection.with do |conn|
-            conn.exec_params(sql, params)
-          end.to_a.dig(0, 'global_position')
+          starting_position = event_global_position(_collection.first) || starting_id
+          return unless starting_position
+
+          order = self.order == :asc ? :desc : :asc
+          starting_position = self.order == :asc ? starting_position - 1 : starting_position + 1
+
+          # Not ideal from the perspective of the amount of records we load here, but this is the only way to read from
+          # the db in the correct way. Direct usage of query builders may result in heavy, unoptimized queries.
+          options = self.options.merge(
+            from_position: starting_position, max_count: per_page, direction: order, resolve_link_tos: false
+          )
+          PgEventstore.client(config_name).read(
+            PgEventstore::Stream.all_stream,
+            options:,
+            middlewares: []
+          ).last&.global_position
         end
 
         # @return [Integer]
         def total_count
           @total_count ||=
             begin
-              sql_builder = QueryBuilders::EventsFiltering.events_filtering(@stream, options).to_sql_builder
-              sql_builder.remove_limit.remove_group.remove_order
+              filters_collection = QueryBuilders::Filters::Collection.from_options(options)
+              sql_builder = QueryBuilders::IndexBasedEventsFiltering.sql_builder_for_estimate_count(
+                filters_collection.collection
+              )
               count = estimate_count(sql_builder)
               return count if count > MAX_NUMBER_TO_COUNT
 
@@ -79,6 +68,13 @@ module PgEventstore
 
         private
 
+        def _collection
+          @_collection ||= PgEventstore.client(config_name).read(
+            PgEventstore::Stream.all_stream,
+            options: options.merge(from_position: starting_id, max_count: per_page + 1, direction: order)
+          )
+        end
+
         # @param event [PgEventstore::Event, nil]
         # @return [Integer, nil]
         def event_global_position(event)

data/lib/pg_eventstore/web/paginator/helpers.rb

@@ -80,24 +80,31 @@ module PgEventstore
           parts.join(delimiter)
         end
 
-        # @param event [PgEventstore::Event]
+        # @param stream [PgEventstore::Stream]
         # @return [String]
-        def stream_path(event)
+        def stream_path(stream)
           build_path(
             {
               filter: {
                 streams: [
                   {
-                    context: escape_empty_string(event.stream.context),
-                    stream_name: escape_empty_string(event.stream.stream_name),
-                    stream_id: escape_empty_string(event.stream.stream_id),
+                    context: escape_empty_string(stream.context),
+                    stream_name: escape_empty_string(stream.stream_name),
+                    stream_id: escape_empty_string(stream.stream_id),
                   },
                 ],
               },
-            }
+            },
+            base_url: '/'
           )
         end
 
+        # @param marker [String]
+        # @return [String]
+        def event_marker_path(marker)
+          build_path({ filter: { markers: [escape_empty_string(marker)] } }, base_url: '/')
+        end
+
         # @param str [String]
         # @return [String]
         def empty_characters_fallback(str)
@@ -118,11 +125,11 @@ module PgEventstore
 
         # @param params [Hash, Array]
         # @return [String]
-        def build_path(params)
+        def build_path(params, base_url: request.path)
           encoded_params = Rack::Utils.build_nested_query(params)
-          return request.path if encoded_params.empty?
+          return base_url if encoded_params.empty?
 
-          "#{request.path}?#{encoded_params}"
+          "#{base_url}?#{encoded_params}"
         end
       end
     end

data/lib/pg_eventstore/web/paginator/markers_collection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class MarkersCollection < BaseCollection
+        # @return [Integer]
+        PER_PAGE = 10
+
+        # @return [Array<Hash<String => String>>]
+        def collection
+          @collection ||=
+            begin
+              sql_builder = SQLBuilder.new.select('name').from('event_markers')
+              sql_builder.where("name #{direction_operator} ?", starting_id) if starting_id
+              sql_builder.where('name like ?', "#{options[:query]}%")
+              sql_builder.order("name #{order}").limit(per_page)
+              connection.with do |conn|
+                conn.exec_params(*sql_builder.to_exec_params)
+              end.to_a
+            end
+        end
+
+        # @return [String, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          starting_id = collection.first['name']
+          sql_builder = SQLBuilder.new.select('name').from('event_markers')
+          sql_builder.where("name #{direction_operator} ?", starting_id)
+          sql_builder.where('name like ?', "#{options[:query]}%")
+          sql_builder.order("name #{order}").limit(1).offset(per_page)
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'name')
+        end
+
+        private
+
+        # @return [String]
+        def direction_operator
+          order == :asc ? '>=' : '<='
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/stream_contexts_collection.rb

@@ -14,7 +14,7 @@ module PgEventstore
               sql_builder = SQLBuilder.new.select('context').from('partitions')
               sql_builder.where('stream_name is null and event_type is null')
               sql_builder.where("context #{direction_operator} ?", starting_id) if starting_id
-              sql_builder.where('context ilike ?', "%#{options[:query]}%")
+              compute_context_filter(sql_builder)
               sql_builder.limit(per_page).order("context #{order}")
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
@@ -30,7 +30,7 @@ module PgEventstore
           sql_builder = SQLBuilder.new.select('context').from('partitions')
           sql_builder.where('stream_name is null and event_type is null')
           sql_builder.where("context #{direction_operator} ?", starting_id)
-          sql_builder.where('context ilike ?', "%#{options[:query]}%")
+          compute_context_filter(sql_builder)
           sql_builder.limit(1).offset(per_page).order("context #{order}")
 
           connection.with do |conn|
@@ -44,6 +44,17 @@ module PgEventstore
         def direction_operator
           order == :asc ? '>=' : '<='
         end
+
+        # @param builder [PgEventstore::SQLBuilder]
+        # @return [void]
+        def compute_context_filter(builder)
+          query = options[:query].to_s
+          if query.size < MIN_QUERY_SIZE_FOR_ADVANCE_SEARCH
+            builder.where('context like ?', "#{query}%")
+          else
+            builder.where('context ilike ?', "%#{query}%")
+          end
+        end
       end
     end
   end

data/lib/pg_eventstore/web/paginator/stream_ids_collection.rb

@@ -11,11 +11,9 @@ module PgEventstore
         def collection
           @collection ||=
             begin
-              sql_builder = SQLBuilder.new.select('stream_id').from(Event::PRIMARY_TABLE_NAME)
-              sql_builder.where('context = ? and stream_name = ?', options[:context], options[:stream_name])
-              sql_builder.where('stream_id like ?', "#{options[:query]}%")
-              sql_builder.where("stream_id #{direction_operator} ?", starting_id) if starting_id
-              sql_builder.group('stream_id').limit(per_page).order("stream_id #{order}")
+              sql_builder = streams_index_sql_builder(from_id: starting_id)
+              sql_builder.limit(per_page)
+
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
               end.to_a
@@ -26,12 +24,8 @@ module PgEventstore
         def next_page_starting_id
           return unless collection.size == per_page
 
-          starting_id = collection.first['stream_id']
-          sql_builder = SQLBuilder.new.select('stream_id').from(Event::PRIMARY_TABLE_NAME)
-          sql_builder.where("stream_id #{direction_operator} ?", starting_id)
-          sql_builder.where('stream_id like ?', "#{options[:query]}%")
-          sql_builder.where('context = ? and stream_name = ?', options[:context], options[:stream_name])
-          sql_builder.group('stream_id').limit(1).offset(per_page).order("stream_id #{order}")
+          sql_builder = streams_index_sql_builder(from_id: collection.first['stream_id'])
+          sql_builder.limit(1).offset(per_page)
 
           connection.with do |conn|
             conn.exec_params(*sql_builder.to_exec_params)
@@ -40,6 +34,22 @@ module PgEventstore
 
         private
 
+        def partitions_sql_builder
+          filters = QueryBuilders::Filters::Collection.from_options(
+            { filter: { streams: [{ context: options[:context], stream_name: options[:stream_name] }] } }
+          )
+          QueryBuilders::PartitionsFiltering.assemble_sql_builder(filters, scope: :stream_name).unselect.select('id')
+        end
+
+        def streams_index_sql_builder(from_id: nil)
+          sql_builder = SQLBuilder.new.select('stream_id')
+          sql_builder.from(QueryBuilders::StreamsGlobalIndexFiltering::PRIMARY_TABLE_NAME)
+          sql_builder.where('partition_id = ?', partitions_sql_builder)
+          sql_builder.where('stream_id like ?', "#{options[:query]}%")
+          sql_builder.where("stream_id #{direction_operator} ?", from_id) if from_id
+          sql_builder.order("stream_id #{order}")
+        end
+
         # @return [String]
         def direction_operator
           order == :asc ? '>=' : '<='

data/lib/pg_eventstore/web/paginator/stream_names_collection.rb

@@ -12,9 +12,9 @@ module PgEventstore
           @collection ||=
             begin
               sql_builder = SQLBuilder.new.select('stream_name').from('partitions')
-              sql_builder.where('event_type is null and context = ?', options[:context])
-              sql_builder.where('stream_name ilike ?', "%#{options[:query]}%")
+              sql_builder.where('event_type is null and stream_name is not null and context = ?', options[:context])
               sql_builder.where("stream_name #{direction_operator} ?", starting_id) if starting_id
+              compute_stream_name_filter(sql_builder)
               sql_builder.limit(per_page).order("stream_name #{order}")
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
@@ -29,10 +29,9 @@ module PgEventstore
           starting_id = collection.first['stream_name']
           sql_builder = SQLBuilder.new.select('stream_name').from('partitions')
           sql_builder.where("stream_name #{direction_operator} ?", starting_id)
-          sql_builder.where('stream_name ilike ?', "%#{options[:query]}%")
+          compute_stream_name_filter(sql_builder)
           sql_builder.where('event_type is null and context = ?', options[:context])
           sql_builder.limit(1).offset(per_page).order("stream_name #{order}")
-
           connection.with do |conn|
             conn.exec_params(*sql_builder.to_exec_params)
           end.to_a.dig(0, 'stream_name')
@@ -44,6 +43,21 @@ module PgEventstore
         def direction_operator
           order == :asc ? '>=' : '<='
         end
+
+        # @param builder [PgEventstore::SQLBuilder]
+        # @return [void]
+        def compute_stream_name_filter(builder)
+          query = options[:query].to_s
+          if query.size < MIN_QUERY_SIZE_FOR_ADVANCE_SEARCH
+            builder.where('stream_name like ?', "#{query}%")
+          else
+            builder.where(
+              'context || ? || stream_name ilike ?',
+              PgEventstore::Event::SYSTEM_SYMBOL,
+              "#{options[:context]}#{PgEventstore::Event::SYSTEM_SYMBOL}%#{query}%"
+            )
+          end
+        end
       end
     end
   end

data/lib/pg_eventstore/web/paginator/streams_collection.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class StreamsCollection < BaseCollection
+        # @return [Hash<String => Symbol>] SQL directions, string-to-symbol mapping
+        SQL_DIRECTIONS = {
+          'asc' => :asc,
+          'desc' => :desc,
+        }.tap do |directions|
+          directions.default = :desc
+        end.freeze
+        # @return [Hash<String => Integer>] per page limits, string to Integer mapping
+        PER_PAGE = %w[10 20 50 100 1000].to_h { [_1, _1.to_i] }.tap do |per_page|
+          per_page.default = 10
+        end.freeze
+        # @return [Integer] max number of events after which we don't perform the exact count and keep the estimate
+        #   count instead because of the potential performance degradation.
+        MAX_NUMBER_TO_COUNT = 10_000
+
+        # @return [Array<PgEventstore::Stream>]
+        def collection
+          @collection ||= PgEventstore.client(config_name).read_streams(
+            options: { from_position: starting_id, max_count: per_page, direction: order }
+          )
+        end
+
+        # @return [Integer, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          from_position = collection.first&.starting_position
+          sql_builder = QueryBuilders::StreamsGlobalIndexFiltering.sql_builder_for_basic_pagination(
+            from_position:, max_count: 1, direction: order
+          ).unselect.select('starting_position').offset(per_page)
+          starting_position(sql_builder)
+        end
+
+        # @return [Integer, nil]
+        def prev_page_starting_id
+          from_position = collection.first&.starting_position || starting_id
+          sql_builder = QueryBuilders::StreamsGlobalIndexFiltering.sql_builder_for_basic_pagination(
+            from_position:, max_count: per_page, direction: order == :asc ? :desc : :asc
+          ).unselect.select('starting_position').offset(1)
+          sql_builder = SQLBuilder.new.select('starting_position').from(sql_builder)
+          sql_builder.order("starting_position #{order}").limit(1)
+          starting_position(sql_builder)
+        end
+
+        # @return [Integer]
+        def total_count
+          @total_count ||=
+            begin
+              sql_builder = QueryBuilders::StreamsGlobalIndexFiltering.sql_builder_for_basic_pagination({})
+              sql_builder.remove_limit.remove_group.remove_order
+              count = estimate_count(sql_builder)
+              return count if count > MAX_NUMBER_TO_COUNT
+
+              regular_count(sql_builder)
+            end
+        end
+
+        private
+
+        # @param sql_builder [PgEventstore::SQLBuilder]
+        # @return [Integer]
+        def estimate_count(sql_builder)
+          sql, params = sql_builder.to_exec_params
+          connection.with do |conn|
+            conn.exec_params("EXPLAIN #{sql}", params)
+          end.to_a.first['QUERY PLAN'].match(/rows=(\d+)/)[1].to_i
+        end
+
+        # @param sql_builder [PgEventstore::SQLBuilder]
+        # @return [Integer]
+        def regular_count(sql_builder)
+          sql_builder.unselect.select('count(*) as count_all')
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.first['count_all']
+        end
+
+        # @param sql_builder [PgEventstore::SQLBuilder]
+        # @return [Integer, nil]
+        def starting_position(sql_builder)
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'starting_position')
+        end
+      end
+    end
+  end
+end