pg_eventstore 1.13.4 → 3.0.0

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -6,19 +6,22 @@ require_relative 'basic_runner'
 require_relative 'runner_recovery_strategy'
 require_relative 'runner_recovery_strategies'
 require_relative 'subscription'
-require_relative 'synchronized_array'
+require_relative 'events_processor_consumer'
 require_relative 'events_processor'
 require_relative 'subscription_handler_performance'
 require_relative 'subscription_runner'
-require_relative 'subscription_position_evaluation'
 require_relative 'subscriptions_set'
+require_relative 'subscription_feed_strategy'
 require_relative 'subscription_runners_feeder'
 require_relative 'subscriptions_set_lifecycle'
 require_relative 'subscriptions_lifecycle'
 require_relative 'callback_handlers/subscription_feeder_handlers'
 require_relative 'callback_handlers/subscription_runner_handlers'
 require_relative 'callback_handlers/events_processor_handlers'
+require_relative 'callback_handlers/events_subscription_position_worker_handlers'
 require_relative 'callback_handlers/commands_handler_handlers'
+require_relative 'commands_handler'
+require_relative 'events_subscription_position_worker'
 require_relative 'subscription_feeder'
 require_relative 'extensions/command_class_lookup_extension'
 require_relative 'extensions/base_command_extension'
@@ -26,10 +29,11 @@ require_relative 'subscription_feeder_commands'
 require_relative 'subscription_runner_commands'
 require_relative 'queries/subscription_command_queries'
 require_relative 'queries/subscription_queries'
+require_relative 'queries/event_subscription_position_queries'
 require_relative 'queries/subscriptions_set_command_queries'
 require_relative 'queries/subscriptions_set_queries'
-require_relative 'queries/service_queries'
-require_relative 'commands_handler'
+require_relative 'replica_subscription_handler'
+require_relative 'replica_subscription_runner'
 
 module PgEventstore
   # The public Subscriptions API, available to the user.
@@ -42,7 +46,6 @@ module PgEventstore
     private :config
 
     def_delegators :@subscription_feeder, :stop, :running?
-    def_delegators :@subscriptions_lifecycle, :force_lock!
 
     # @param config [PgEventstore::Config]
     # @param set_name [String]
@@ -61,10 +64,10 @@ module PgEventstore
         }
       )
       @subscriptions_lifecycle = SubscriptionsLifecycle.new(
-        config_name, @subscriptions_set_lifecycle, force_lock: force_lock
+        config_name, @subscriptions_set_lifecycle, force_lock:
       )
       @subscription_feeder = SubscriptionFeeder.new(
-        config_name: config_name,
+        config_name:,
         subscriptions_set_lifecycle: @subscriptions_set_lifecycle,
         subscriptions_lifecycle: @subscriptions_lifecycle
       )
@@ -72,8 +75,8 @@ module PgEventstore
 
     # @param subscription_name [String] subscription's name
     # @param handler [#call] subscription's handler
-    # @param options [Hash] request options
-    # @option options [Integer, Symbol] :from_position a starting subscription position
+    # @param options [Hash] subscription options
+    # @option options [Integer] :from_position a starting subscription position
     # @option options [Boolean] :resolve_link_tos When using projections to create new events you
     #   can set whether the generated events are pointers to existing events. Setting this option to true tells
     #   PgEventstore to return the original event instead a link event.
@@ -92,6 +95,7 @@ module PgEventstore
     #   notification about failed subscription.
     # @param graceful_shutdown_timeout [integer, Float] the number of seconds to wait until force-shutdown the
     #   subscription during the stop process
+    # @param in_batches [Boolean] whether a batch of events should be yielded instead a single event
     # @return [void]
     def subscribe(subscription_name, handler:, options: {}, middlewares: nil,
                   pull_interval: config.subscription_pull_interval,
@@ -99,23 +103,78 @@ module PgEventstore
                   retries_interval: config.subscription_retries_interval,
                   restart_terminator: config.subscription_restart_terminator,
                   failed_subscription_notifier: config.failed_subscription_notifier,
-                  graceful_shutdown_timeout: config.subscription_graceful_shutdown_timeout)
+                  graceful_shutdown_timeout: config.subscription_graceful_shutdown_timeout,
+                  in_batches: false)
       subscription = Subscription.using_connection(config.name).new(
-        set: @set_name, name: subscription_name, options: options, chunk_query_interval: pull_interval,
+        set: @set_name, name: subscription_name, options:, chunk_query_interval: pull_interval,
         max_restarts_number: max_retries, time_between_restarts: retries_interval
       )
+      consumer_class = EventsProcessorConsumer.consumer_class(in_batches)
       runner = SubscriptionRunner.new(
         stats: SubscriptionHandlerPerformance.new,
         events_processor: EventsProcessor.new(
-          create_raw_event_handler(middlewares, handler),
-          graceful_shutdown_timeout: graceful_shutdown_timeout,
+          graceful_shutdown_timeout:,
+          consumer: consumer_class.create_consumer(handler, deserializer(middlewares)),
+          recovery_strategies: recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
+        ),
+        subscription:
+      )
+
+      @subscriptions_lifecycle.runners.push(runner)
+      true
+    end
+
+    # @param subscription_name [String] subscription's name. For example, you can name it after the target database:
+    #   "Target: my_eventstore_replica1"
+    # @param replica_config_name [Symbol] the destination replica database config to replicate events into. You have to
+    #   have it preconfigured with PgEventstore.configure(). Example:
+    #   PgEventstore.configure(name: :my_eventstore_replica1) do |config|
+    #     config.pg_uri = 'postgresql://postgres:postgres@localhost:5432/my_eventstore_replica1'
+    #   end
+    #   Refer to the docs/configuration.md for more info
+    # @param options [Hash] subscription options
+    # @option options [Integer] :from_position a starting subscription position
+    # @option options [Hash] :filter provide it to filter events. It works the same way as a :filter option of
+    #   {PgEventstore::Client#read} method. Use this option when you want to replicate certain set of events.
+    # @param max_events_to_replicate [Integer] set the upper limit of how many events the handler can copy per turn
+    # @param pull_interval [Integer, Float] an interval in seconds to determine how often to query new events of the
+    #   given subscription.
+    # @param max_retries [Integer] max number of retries of failed Subscription
+    # @param retries_interval [Integer, Float] a delay between retries of failed Subscription
+    # @param restart_terminator [#call, nil] a callable object which is invoked with PgEventstore::Subscription instance
+    #   to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
+    # @param failed_subscription_notifier [#call, nil] a callable object which is invoked with
+    #   PgEventstore::Subscription instance and error instance after the related subscription died due to error and no
+    #   longer can be automatically restarted due to max retries number reached. You can use this hook to send a
+    #   notification about failed subscription.
+    # @param graceful_shutdown_timeout [Integer, Float] the number of seconds to wait until force-shutdown the
+    #   subscription during the stop process
+    # @return [void]
+    def create_replication(subscription_name,
+                           replica_config_name,
+                           options: {},
+                           max_events_to_replicate: config.max_events_to_replicate,
+                           pull_interval: config.subscription_pull_interval,
+                           max_retries: config.subscription_max_retries,
+                           retries_interval: config.subscription_retries_interval,
+                           restart_terminator: config.subscription_restart_terminator,
+                           failed_subscription_notifier: config.failed_subscription_notifier,
+                           graceful_shutdown_timeout: config.subscription_graceful_shutdown_timeout)
+      Utils.assert_node_role!(config, [Config::NodeRole::PRIMARY])
+      subscription = Subscription.using_connection(config.name).new(
+        set: @set_name, name: subscription_name, options:, chunk_query_interval: pull_interval,
+        max_restarts_number: max_retries, time_between_restarts: retries_interval
+      )
+      runner = ReplicaSubscriptionRunner.new(
+        stats: SubscriptionHandlerPerformance.new,
+        events_processor: EventsProcessor.new(
+          graceful_shutdown_timeout:,
+          consumer: EventsProcessorConsumer::Replica.create_consumer(config_name, replica_config_name),
           recovery_strategies: recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
         ),
-        subscription: subscription,
-        position_evaluation: SubscriptionPositionEvaluation.new(
-          config_name: config.name,
-          filter_options: options[:filter] || {}
-        )
+        subscription:,
+        max_events_per_chunk: max_events_to_replicate,
+        initial_events_per_chunk: max_events_to_replicate
       )
 
       @subscriptions_lifecycle.runners.push(runner)
@@ -156,18 +215,14 @@ module PgEventstore
     private
 
     # @return [Object] the result of the passed block
-    def run_cli_callbacks(&blk)
+    def run_cli_callbacks(&)
       return yield unless defined?(::PgEventstore::CLI)
 
-      PgEventstore::CLI.callbacks.run_callbacks(:start_manager, self, &blk)
+      PgEventstore::CLI.callbacks.run_callbacks(:start_manager, self, &)
     end
 
-    # @param middlewares [Array<Symbol>, nil]
-    # @param handler [#call]
-    # @return [Proc]
-    def create_raw_event_handler(middlewares, handler)
-      deserializer = EventDeserializer.new(select_middlewares(middlewares), config.event_class_resolver)
-      ->(raw_event) { handler.call(deserializer.deserialize(raw_event)) }
+    def deserializer(middlewares)
+      EventDeserializer.new(select_middlewares(middlewares), config.event_class_resolver)
     end
 
     # @param middlewares [Array, nil]
@@ -186,9 +241,9 @@ module PgEventstore
       [
         RunnerRecoveryStrategies::RestoreConnection.new(config_name),
         RunnerRecoveryStrategies::RestoreSubscriptionRunner.new(
-          subscription: subscription,
-          restart_terminator: restart_terminator,
-          failed_subscription_notifier: failed_subscription_notifier
+          subscription:,
+          restart_terminator:,
+          failed_subscription_notifier:
         ),
       ]
     end

data/lib/pg_eventstore/{subscriptions/synchronized_array.rb → synchronized_array.rb}

@@ -13,6 +13,9 @@ module PgEventstore
     alias old_clear clear
     alias old_size size
     alias old_empty? empty?
+    alias old_slice slice
+    alias old_slice! slice!
+    alias old_at at
 
     def shift(...)
       synchronize { old_shift(...) }
@@ -37,5 +40,17 @@ module PgEventstore
     def empty?(...)
       synchronize { old_empty?(...) }
     end
+
+    def slice(...)
+      synchronize { old_slice(...) }
+    end
+
+    def slice!(...)
+      synchronize { old_slice!(...) }
+    end
+
+    def at(...)
+      synchronize { old_at(...) }
+    end
   end
 end

data/lib/pg_eventstore/tasks/setup.rake

@@ -2,50 +2,53 @@
 
 require 'uri'
 
-helpers = Class.new do
-  class << self
-    def postgres_uri
-      @postgres_uri ||=
-        begin
-          uri = URI.parse(ENV.fetch('PG_EVENTSTORE_URI'))
-          uri.path = '/postgres'
-          uri.to_s
-        end
-    end
+module PgEventstore
+  class MigrationHelpers
+    class << self
+      def postgres_uri
+        @postgres_uri ||=
+          begin
+            uri = URI.parse(ENV.fetch('PG_EVENTSTORE_URI'))
+            uri.path = '/postgres'
+            uri.to_s
+          end
+      end
 
-    def db_name
-      @db_name ||= URI.parse(ENV.fetch('PG_EVENTSTORE_URI')).path&.delete('/')
+      def db_name
+        @db_name ||= URI.parse(ENV.fetch('PG_EVENTSTORE_URI')).path&.delete('/')
+      end
     end
   end
 end
 
+PgEventstore.configure(name: :_postgres_db_connection) do |config|
+  config.pg_uri = PgEventstore::MigrationHelpers.postgres_uri
+end
+
+PgEventstore.configure(name: :_eventstore_db_connection) do |config|
+  config.pg_uri = ENV['PG_EVENTSTORE_URI']
+end
+
 namespace :pg_eventstore do
   desc 'Creates events table, indexes, etc.'
   task :create do
-    PgEventstore.configure do |config|
-      config.pg_uri = helpers.postgres_uri
-    end
-
-    PgEventstore.connection.with do |conn|
+    PgEventstore.connection(:_postgres_db_connection).with do |conn|
       exists =
-        conn.exec_params('SELECT 1 as exists FROM pg_database where datname = $1', [helpers.db_name]).
+        conn.exec_params('SELECT 1 as exists FROM pg_database where datname = $1', [PgEventstore::MigrationHelpers.db_name]).
         first&.dig('exists')
       if exists
-        puts "#{helpers.db_name} already exists. Skipping."
+        puts "#{PgEventstore::MigrationHelpers.db_name} already exists. Skipping."
       else
-        conn.exec("CREATE DATABASE #{conn.escape_string(helpers.db_name)} WITH OWNER #{conn.escape_string(conn.user)}")
+        escaped_db_name = conn.escape_string(PgEventstore::MigrationHelpers.db_name)
+        conn.exec("CREATE DATABASE #{escaped_db_name} WITH OWNER #{conn.escape_string(conn.user)}")
       end
     end
   end
 
   task :migrate do
-    PgEventstore.configure do |config|
-      config.pg_uri = ENV['PG_EVENTSTORE_URI']
-    end
+    migration_files_root = File.join(Gem.loaded_specs.fetch('pg_eventstore').gem_dir, 'db/migrations')
 
-    migration_files_root = "#{Gem::Specification.find_by_name('pg_eventstore').gem_dir}/db/migrations"
-
-    PgEventstore.connection.with do |conn|
+    PgEventstore.connection(:_eventstore_db_connection).with do |conn|
       conn.exec('CREATE TABLE IF NOT EXISTS migrations (number int NOT NULL)')
       latest_migration =
         conn.exec('SELECT number FROM migrations ORDER BY number DESC LIMIT 1').to_a.dig(0, 'number') || -1
@@ -56,7 +59,7 @@ namespace :pg_eventstore do
           next if latest_migration >= number
 
           if File.extname(f_name) == '.rb'
-            load f_name
+            load(f_name, true)
           else
             conn.exec(File.read(f_name))
           end
@@ -68,12 +71,8 @@ namespace :pg_eventstore do
 
   desc 'Drops events table and related pg_eventstore objects.'
   task :drop do
-    PgEventstore.configure do |config|
-      config.pg_uri = helpers.postgres_uri
-    end
-
-    PgEventstore.connection.with do |conn|
-      conn.exec("DROP DATABASE IF EXISTS #{conn.escape_string(helpers.db_name)}")
+    PgEventstore.connection(:_postgres_db_connection).with do |conn|
+      conn.exec("DROP DATABASE IF EXISTS #{conn.escape_string(PgEventstore::MigrationHelpers.db_name)}")
     end
   end
 end

data/lib/pg_eventstore/utils.rb

@@ -124,6 +124,45 @@ module PgEventstore
 
         wrapped_exception
       end
+
+      # Yields the given block and measures its execution time
+      # @return [Float] number of seconds the block took to execute
+      def benchmark
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      end
+
+      # @param truthy [boolish]
+      # @param message [String, nil]
+      # @raise ArgumentError
+      def assert!(truthy, message = nil)
+        raise ArgumentError, message unless truthy
+      end
+
+      # @param obj
+      # @raise NotImplementedError
+      def missing_implementation!(obj)
+        raise NotImplementedError, obj.inspect
+      end
+
+      # @param config [PgEventstore::Config]
+      # @param expected_roles [Array<Symbol>]
+      # @return [void]
+      def assert_node_role!(config, expected_roles)
+        return if expected_roles.include?(config.eventstore_role)
+
+        raise "You can't perform this operation on #{config.eventstore_role.inspect} node!"
+      end
+
+      # Takes a collection of partition ids, the number of partitions per call and determines the position in the
+      # partition_ids at which we have max_partitions_to_resolve_per_call unique partitions
+      # @param partition_ids [Array<Integer>]
+      # @param max_partitions_to_resolve_per_call [Integer]
+      # @return [Range]
+      def range_to_slice(partition_ids, max_partitions_to_resolve_per_call)
+        # This is stub, used for indexing
+      end
     end
   end
 end

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = '1.13.4'
+  VERSION = '3.0.0'
 end

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]
@@ -87,7 +102,7 @@ module PgEventstore
             attrs.transform_values { escape_empty_string(_1) }
           end
           halt 200, {
-            results: results,
+            results:,
             pagination: { more: !collection.next_page_starting_id.nil?, starting_id: collection.next_page_starting_id },
           }.to_json
         end
@@ -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: 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
@@ -188,8 +261,8 @@ module PgEventstore
           connection, @current_set, state: params[:state]
         ).subscriptions
         @association = Subscriptions::SubscriptionsToSetAssociation.new(
-          subscriptions_set: subscriptions_set,
-          subscriptions: subscriptions
+          subscriptions_set:,
+          subscriptions:
         )
         erb :'subscriptions/index'
       end
@@ -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'))
@@ -301,7 +385,7 @@ module PgEventstore
         ).first
         if event&.global_position == global_position
           begin
-            PgEventstore.maintenance(current_config).delete_event(event, force: force)
+            PgEventstore.maintenance(current_config).delete_event(event, force:)
             self.flash_message = {
               message: "An event at global position #{event.global_position} has been deleted successfully.",
               kind: 'success',

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