pg_eventstore 2.0.0 → 3.0.0

data/lib/pg_eventstore/query_builders/read_cursor/stream_cursor.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryBuilders
+    module ReadCursor
+      # @!visibility private
+      class StreamCursor
+        class RegularStreamCursor
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute from_revision
+          #   @return [Integer, nil]
+          attribute(:from_revision)
+          # @!attribute to_revision
+          #   @return [Integer, nil]
+          attribute(:to_revision)
+          # @!attribute direction
+          #   @return [String, Symbol, nil]
+          attribute(:direction)
+          # @!attribute max_count
+          #   @return [Integer, nil]
+          attribute(:max_count)
+        end
+
+        class AllStreamCursor
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute from_position
+          #   @return [Integer, nil]
+          attribute(:from_position)
+          # @!attribute to_position
+          #   @return [Integer, nil]
+          attribute(:to_position)
+          # @!attribute direction
+          #   @return [String, Symbol, nil]
+          attribute(:direction)
+          # @!attribute max_count
+          #   @return [Integer, nil]
+          attribute(:max_count)
+        end
+
+        class << self
+          # @param options [Hash]
+          # @option options [Integer, nil] :from_position
+          # @option options [Integer, nil] :to_position
+          # @option options [String, Symbol, nil] :direction
+          # @option options [Integer, nil] :max_count
+          # @return [PgEventstore::QueryBuilders::ReadCursor::StreamCursor]
+          def from_options(options)
+            new(AllStreamCursor.new(**options))
+          end
+
+          # @param options [Hash]
+          # @option options [Integer, nil] :from_position for "all" stream
+          # @option options [Integer, nil] :to_position for "all" stream
+          # @option options [Integer, nil] :from_revision for regular stream
+          # @option options [Integer, nil] :to_revision for regular stream
+          # @option options [String, Symbol, nil] :direction
+          # @option options [Integer, nil] :max_count
+          # @return [PgEventstore::QueryBuilders::ReadCursor::StreamCursor]
+          def from_stream_and_options(stream, options)
+            return new(AllStreamCursor.new(**options)) if stream.all_stream?
+
+            new(RegularStreamCursor.new(**options))
+          end
+        end
+
+        # @param cursor [ReadCursor::RegularStreamCursor, ReadCursor::RegularStreamCursor]
+        def initialize(cursor)
+          @cursor = cursor
+        end
+
+        # @return [Integer, nil]
+        def from
+          case @cursor
+          when RegularStreamCursor
+            @cursor.from_revision
+          when AllStreamCursor
+            @cursor.from_position
+          else
+            Utils.missing_implementation!(@cursor)
+          end
+        end
+
+        # @return [Integer, nil]
+        def to
+          case @cursor
+          when RegularStreamCursor
+            @cursor.to_revision
+          when AllStreamCursor
+            @cursor.to_position
+          else
+            Utils.missing_implementation!(@cursor)
+          end
+        end
+
+        # @return [String, Symbol, nil]
+        def direction
+          @cursor.direction
+        end
+
+        # @return [Integer, nil]
+        def max_count
+          @cursor.max_count
+        end
+
+        # @param val [Integer, nil]
+        # @return [void]
+        def max_count=(val)
+          @cursor.max_count = val
+        end
+
+        # @return [Boolean]
+        def all_stream_cursor?
+          @cursor.is_a?(AllStreamCursor)
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/query_builders/streams_global_index_filtering.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryBuilders
+    # @!visibility private
+    class StreamsGlobalIndexFiltering
+      include BasicFiltering
+
+      # @return [String]
+      PRIMARY_TABLE_NAME = 'streams_global_index'
+      # @return [Integer]
+      DEFAULT_LIMIT = 1000
+
+      class << self
+        # @param options [Hash]
+        # @option options [Integer, nil] :from_position
+        # @option options [Integer, nil] :max_count
+        # @option options [String, Symbol, nil] :direction
+        # @return [PgEventstore::SQLBuilder]
+        def sql_builder_for_basic_pagination(options)
+          streams_idx_filtering = QueryBuilders::StreamsGlobalIndexFiltering.new
+          streams_idx_filtering.from_position(options[:from_position], options[:direction])
+          streams_idx_filtering.limit(options[:max_count])
+          streams_idx_filtering.add_starting_position_direction(options[:direction])
+          streams_idx_filtering.to_sql_builder
+        end
+      end
+
+      def initialize
+        @sql_builder = SQLBuilder.new.select("#{to_table_name}.*").from(to_table_name)
+      end
+
+      def to_sql_builder
+        @sql_builder
+      end
+
+      # @return [String]
+      def to_table_name
+        PRIMARY_TABLE_NAME
+      end
+
+      # @param filter_row [PgEventstore::QueryBuilders::Filters::FilterRow]
+      # @return [void]
+      def add_filter_row(filter_row)
+        stream_filter = filter_row.stream_filter
+        raise ArgumentError, "Invalid stream filter: #{stream_filter}" unless stream_filter&.stream?
+
+        affected_partitions = PartitionsFiltering.from_filter_row(filter_row, scope: :stream_name)
+        builder = affected_partitions.select_id_only
+        @sql_builder.where_or('partition_id = ? and stream_id = ?', builder, stream_filter.stream_id)
+      end
+
+      # @param position [Integer, nil]
+      # @param direction [Symbol, String, nil]
+      # @return [void]
+      def from_position(position, direction)
+        return if position.nil?
+
+        @sql_builder.where("starting_position #{direction_operator_from(direction)} ?", position)
+      end
+
+      # @param limit [Integer, nil]
+      # @return [void]
+      def limit(limit)
+        @sql_builder.limit(limit || DEFAULT_LIMIT)
+      end
+
+      # @param direction [Symbol, String, nil]
+      # @return [void]
+      def add_starting_position_direction(direction)
+        @sql_builder.order("#{to_table_name}.starting_position #{SQL_DIRECTIONS[direction]}")
+      end
+
+      private
+
+      # @param direction [String, Symbol, nil]
+      # @return [String]
+      def direction_operator_from(direction)
+        SQL_DIRECTIONS[direction] == 'ASC' ? '>=' : '<='
+      end
+    end
+  end
+end

data/lib/pg_eventstore/query_builders/subscription_events_filtering.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryBuilders
+    # @!visibility private
+    class SubscriptionEventsFiltering
+      include BasicFiltering
+
+      class << self
+        # @param id [integer]
+        # @param options [Hash]
+        # @option options [Integer] :from_position
+        # @option options [Integer] :to_position
+        # @option options [Integer] :max_count
+        # @return [PgEventstore::QueryBuilders::SubscriptionEventsFiltering]
+        def build(id, options)
+          index_filter = new(id)
+          index_filter.from_position(options[:from_position])
+          index_filter.to_position(options[:to_position])
+          index_filter.add_limit(options[:max_count])
+          index_filter
+        end
+      end
+
+      # @param subscription_id [Integer]
+      def initialize(subscription_id)
+        @subscription_id = subscription_id
+        @from_position = 0
+        @to_position = 0
+        @max_count = 0
+        @sql_builder = SQLBuilder.new.select("#{to_table_name}.*")
+        compute_from
+      end
+
+      def to_sql_builder
+        compute_from
+        @sql_builder
+      end
+
+      # @param position [Integer, nil]
+      # @return [void]
+      def from_position(position)
+        raise ArgumentError, 'position must be valid number' unless position.is_a?(Integer)
+
+        @from_position = position
+      end
+
+      # @param position [Integer, nil]
+      # @return [void]
+      def to_position(position)
+        raise ArgumentError, 'position must be valid number' unless position.is_a?(Integer)
+
+        @to_position = position
+      end
+
+      # @param limit [Integer, nil]
+      # @return [void]
+      def add_limit(limit)
+        raise ArgumentError, 'limit must be valid number' unless limit.is_a?(Integer)
+
+        @max_count = limit
+      end
+
+      # @return [String]
+      def to_table_name
+        "subscription_#{@subscription_id}"
+      end
+
+      private
+
+      def compute_from
+        @sql_builder.from(
+          "#{to_table_name}(#{@from_position}, #{@to_position}, #{@max_count})",
+          table_alias: to_table_name
+        )
+      end
+    end
+  end
+end

data/lib/pg_eventstore/query_strategy/async.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryStrategy
+    # @!visibility private
+    class Async
+      include QueryStrategy
+
+      # @param connection [PgEventstore::Connection]
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def exec(*)
+        run(:send_query, *)
+      end
+
+      def exec_params(*)
+        run(:send_query_params, *)
+      end
+
+      private
+
+      def run(method, *exec_args)
+        @connection.with do |conn|
+          conn.public_send(method, *exec_args)
+          loop do
+            conn.consume_input
+            break unless conn.is_busy
+
+            Fiber.yield
+          end
+
+          last_result = nil
+          while result = conn.get_result
+            # Check whether result is successful. Raises error if it is not.
+            # Related function is pg_result_check() in pg_result.c
+            result.check_result
+            last_result = result
+          end
+          last_result
+        rescue AsyncRunner::Cancellation
+          cancel_and_drain(conn)
+          Fiber.current.kill
+        end
+      end
+
+      # @param conn [PG::Connection]
+      # @return [void]
+      def cancel_and_drain(conn)
+        cancellation_error = conn.cancel
+        conn.sync_reset if cancellation_error
+
+        while (result = conn.get_result)
+          result.clear
+        end
+      rescue PG::Error
+        # We have unexpected error during the cancellation process. No need to try to restore the connection at this
+        # point and simply throw it out
+        @connection.discard_current_connection
+      end
+    end
+  end
+end

data/lib/pg_eventstore/query_strategy/foreground.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryStrategy
+    class Foreground
+      include QueryStrategy
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def exec(*exec_args)
+        @connection.with do |conn|
+          conn.exec(*exec_args)
+        end
+      end
+
+      def exec_params(*exec_args)
+        @connection.with do |conn|
+          conn.exec_params(*exec_args)
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/query_strategy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  module QueryStrategy
+    # @return [PG::Result]
+    def exec(*args)
+      raise NotImplementedError
+    end
+
+    # @return [PG::Result]
+    def exec_params(*args)
+      raise NotImplementedError
+    end
+  end
+end
+
+require_relative 'query_strategy/async'
+require_relative 'query_strategy/foreground'

data/lib/pg_eventstore/raw_event.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class RawEvent
+    include Extensions::OptionsExtension
+    include Extensions::OptionsDefaults
+
+    # @!attribute id
+    #   @return [String]
+    attribute(:id)
+    # @!attribute context
+    #   @return [String]
+    attribute(:context)
+    # @!attribute stream_name
+    #   @return [String]
+    attribute(:stream_name)
+    # @!attribute stream_id
+    #   @return [String]
+    attribute(:stream_id)
+    # @!attribute global_position
+    #   @return [Integer]
+    attribute(:global_position)
+    # @!attribute stream_revision
+    #   @return [Integer]
+    attribute(:stream_revision)
+    # @!attribute data
+    #   @return [Hash]
+    attribute(:data)
+    # @!attribute metadata
+    #   @return [Hash]
+    attribute(:metadata)
+    # @!attribute link_partition_id
+    #   @return [Integer, nil]
+    attribute(:link_partition_id)
+    # @!attribute created_at
+    #   @return [Time]
+    attribute(:created_at)
+    # @!attribute type
+    #   @return [String]
+    attribute(:type)
+    # @!attribute link_global_position
+    #   @return [Integer, nil]
+    attribute(:link_global_position)
+  end
+end

data/lib/pg_eventstore/rspec/test_helpers.rb

@@ -3,13 +3,14 @@
 module PgEventstore
   module TestHelpers
     class << self
-      def clean_up_db
-        clean_up_data
-        clean_up_partitions
+      def clean_up_db(config = :default)
+        clean_up_data(config)
+        clean_up_partitions(config)
+        clean_up_subscription_functions(config)
       end
 
-      def clean_up_partitions
-        PgEventstore.connection.with do |conn|
+      def clean_up_partitions(config)
+        PgEventstore.connection(config).with do |conn|
           # Dropping parent partition also drops all child partitions
           conn.exec("select tablename from pg_tables where tablename like 'contexts_%'").each do |attrs|
             conn.exec("drop table #{attrs['tablename']}")
@@ -17,8 +18,8 @@ module PgEventstore
         end
       end
 
-      def clean_up_data
-        tables_to_purge = PgEventstore.connection.with do |conn|
+      def clean_up_data(config)
+        tables_to_purge = PgEventstore.connection(config).with do |conn|
           conn.exec(<<~SQL)
             SELECT tablename
             FROM pg_catalog.pg_tables
@@ -27,7 +28,19 @@ module PgEventstore
         end
         tables_to_purge = tables_to_purge.map { |attrs| attrs['tablename'] }
         tables_to_purge.each do |table_name|
-          PgEventstore.connection.with { |c| c.exec("DELETE FROM #{table_name}") }
+          PgEventstore.connection(config).with { |c| c.exec("DELETE FROM #{table_name}") }
+        end
+      end
+
+      def clean_up_subscription_functions(config)
+        functions_to_purge = PgEventstore.connection(config).with do |conn|
+          conn.exec(<<~SQL)
+            SELECT proname FROM pg_proc WHERE proname LIKE 'subscription_%'
+          SQL
+        end
+        functions_to_purge = functions_to_purge.map { _1['proname'] }
+        functions_to_purge.each do |function_name|
+          PgEventstore.connection(config).with { |c| c.exec("drop function #{function_name}") }
         end
       end
     end

data/lib/pg_eventstore/sql_builder.rb

@@ -6,16 +6,35 @@ module PgEventstore
   class SQLBuilder
     class << self
       # @param builders [Array<PgEventstore::SQLBuilder>]
+      # @param mode [Symbol]
       # @return [PgEventstore::SQLBuilder]
-      def union_builders(builders)
-        builders[1..].each_with_object(builders[0]) do |builder, first_builder|
+      def union_builders(builders, mode: :union_all)
+        Utils.assert!(!builders.empty?, "Can't union empty array!")
+
+        union_builder = builders[1..].each_with_object(builders[0]) do |builder, first_builder|
           first_builder.union(builder)
         end
+        union_builder.union_mode = mode
+        union_builder
+      end
+
+      # @param builder [PgEventstore::SQLBuilder]
+      # @return [PgEventstore::SQLBuilder]
+      def wrap_union_builder(builder)
+        new.tap do |b|
+          b.select('*')
+          b.from(builder)
+        end
       end
     end
 
+    UNION_MODES = %i[union_all union_distinct intersect_all intersect_distinct].freeze
+    private_constant :UNION_MODES
+
     # @return [Array<Object>] sql positional values
     attr_reader :positional_values
+    # @return [String, nil]
+    attr_reader :table_alias
     # @return [Integer]
     attr_writer :positional_values_size
 
@@ -33,6 +52,8 @@ module PgEventstore
       @positional_values = []
       @positional_values_size = 0
       @union_values = []
+      @union_mode = :union_all
+      @table_alias = nil
     end
 
     # @param sql [String]
@@ -42,6 +63,14 @@ module PgEventstore
       self
     end
 
+    # @return [PgEventstore::SQLBuilder]
+    def select_id_only
+      raise 'You have to call #from first' unless @table_alias
+
+      remove_order.unselect.select("#{@table_alias}.id")
+      self
+    end
+
     # @return [self]
     def unselect
       @select_values.clear
@@ -64,10 +93,12 @@ module PgEventstore
       self
     end
 
-    # @param table_name [String | SQLBuilder]
+    # @param table_name [String, SQLBuilder]
+    # @param table_alias [String, nil]
     # @return [self]
-    def from(table_name)
+    def from(table_name, table_alias: nil)
       @from_value = table_name
+      @table_alias = table_alias || (table_name.is_a?(SQLBuilder) ? table_name.table_alias : table_name)
       self
     end
 
@@ -92,10 +123,16 @@ module PgEventstore
       self
     end
 
-    # @param limit [Integer]
+    # @param limit [String, Integer]
     # @return [self]
     def limit(limit)
-      @limit_value = limit.to_i
+      @limit_value =
+        case limit
+        when String
+          limit.start_with?(/\d/) ? limit.to_i : PG::Connection.escape(limit)
+        else
+          limit
+        end
       self
     end
 
@@ -139,6 +176,34 @@ module PgEventstore
       _to_exec_params
     end
 
+    def dup
+      self.class.new.tap do |inst|
+        inst.instance_variable_set(:@select_values, @select_values.map(&:dup))
+        inst.instance_variable_set(:@from_value, @from_value&.dup)
+        inst.instance_variable_set(:@where_values, @where_values.dup.transform_values(&:dup))
+        inst.instance_variable_set(:@join_values, @join_values.map(&:dup))
+        inst.instance_variable_set(:@group_values, @group_values.map(&:dup))
+        inst.instance_variable_set(:@order_values, @order_values.map(&:dup))
+        inst.instance_variable_set(:@limit_value, @limit_value&.dup)
+        inst.instance_variable_set(:@offset_value, @offset_value&.dup)
+        inst.instance_variable_set(:@positional_values, @positional_values.map(&:dup))
+        inst.instance_variable_set(:@positional_values_size, @positional_values_size)
+        inst.instance_variable_set(:@union_values, @union_values.map(&:dup))
+        inst.instance_variable_set(:@union_mode, @union_mode.dup)
+        inst.instance_variable_set(:@table_alias, @table_alias.dup)
+      end
+    end
+
+    def union_builder?
+      @union_values.any?
+    end
+
+    def union_mode=(val)
+      raise "Unknown UNION mode #{val.inspect}. Available modes are: #{UNION_MODES}" unless UNION_MODES.include?(val)
+
+      @union_mode = val
+    end
+
     protected
 
     # @return [[String, Array<_>]]
@@ -153,7 +218,7 @@ module PgEventstore
       return @from_value if @from_value.is_a?(String)
 
       sql = merge(@from_value)
-      "(#{sql}) #{@from_value.from_sql}"
+      "(#{sql}) #{@table_alias}"
     end
 
     private
@@ -178,7 +243,20 @@ module PgEventstore
       union_parts += @union_values.map do |builder|
         "(#{merge(builder)})"
       end
-      union_parts.join(' UNION ALL ')
+      union_mode_sql =
+        case @union_mode
+        when :union_all
+          'UNION ALL'
+        when :union_distinct
+          'UNION'
+        when :intersect_all
+          'INTERSECT ALL'
+        when :intersect_distinct
+          'INTERSECT'
+        else
+          Utils.missing_implementation!(@union_mode)
+        end
+      union_parts.join(" #{union_mode_sql} ")
     end
 
     # @return [String]
@@ -207,6 +285,7 @@ module PgEventstore
     # @param builder [PgEventstore::SQLBuilder]
     # @return [String]
     def merge(builder)
+      builder = builder.dup
       builder.positional_values_size = @positional_values_size
       sql_query, positional_values = builder._to_exec_params
       @positional_values.push(*positional_values)