pg_eventstore 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8d3f73730a86f5a8d8849da2faa8c2e24a937e5d062b51928ae3f4034030f54
-  data.tar.gz: 47c6381424341a8b5b86e7dd8e66c0f090d8485755b6e7fc79a9d5e33c5cbde1
+  metadata.gz: fd2524ab67ce1fa009de14a032cdc3d922051420bc2c02e933cb63ee245db02d
+  data.tar.gz: f49867dab08825770aae44e3e1bec38a8144504e3bea2e6618ce47a0d6e8cb54
 SHA512:
-  metadata.gz: fc542c87250be7e2c840ae526cca7dcd9dee55bf7069572b7fc669564c4173a0ec4334a5714dfb92f874cf8717a087ba474ae4aa7697c36dc541883346a12383
-  data.tar.gz: deedd9c173935973dc7330365acd21e4125d5abb9e23975af3a19fc1c6549c3a9944ae0420753034af5d5ed7b60c793d90e90ced0b866ec410a42cc6306400dc
+  metadata.gz: e9925413067ca47159cbd5902f2716bbd9e5fe1e0c63aa7397f077c95878bacc2da57cd65f32160a0e1d70d855e101d16fb6d5aa5b537c9630c4290449db8c16
+  data.tar.gz: 65add6ce6e11ebe0634cec3949709ad3c8d42b105ba9325c5d6d45c45bf2339c0e47f9286dbb71edc8e1c99636aa449adc34926f4a6d57c695c50655609d5451

data/CHANGELOG.md

@@ -1,8 +1,16 @@
-## [0.2.1] - 2023-12-13
+## [0.2.3] - 2023-12-18
+
+- Fix performance when searching by event type only(under certain circumstances PosetgreSQL was picking wrong index).
+
+## [0.2.2] - 2023-12-14
+
+- Fix `pg_eventstore:drop` rake task to also drop `migrations` table
+
+## [0.2.1] - 2023-12-14
 
 Under certain circumstances `PG::TRSerializationFailure` exception wasn't retried. Adjust connection's states list to fix that.
 
-## [0.2.0] - 2023-12-13
+## [0.2.0] - 2023-12-14
 
 - Improve performance by reviewing indexes
 - Implement migrations

data/db/migrations/2_adjust_global_position_index.sql

@@ -0,0 +1,4 @@
+CREATE INDEX idx_events_global_position_including_type ON public.events USING btree (global_position) INCLUDE (type);
+COMMENT ON INDEX idx_events_global_position_including_type IS 'Usually "type" column has low distinct values. Thus, composit index by "type" and "global_position" columns may not be picked by Query Planner properly. Improve an index by "global_position" by including "type" column which allows Query Planner to perform better by picking the correct index.';
+
+DROP INDEX idx_events_global_position;

data/lib/pg_eventstore/client.rb

@@ -27,7 +27,11 @@ module PgEventstore
     # @raise [PgEventstore::WrongExpectedRevisionError]
     def append_to_stream(stream, events_or_event, options: {}, middlewares: nil)
       result =
-        Commands::Append.new(queries(middlewares(middlewares))).call(stream, *events_or_event, options: options)
+        Commands::Append.new(
+          Queries.new(
+            streams: stream_queries, events: event_queries(middlewares(middlewares)), transactions: transaction_queries
+          )
+        ).call(stream, *events_or_event, options: options)
       events_or_event.is_a?(Array) ? result : result.first
     end
 
@@ -43,7 +47,7 @@ module PgEventstore
     #
     # @return the result of the given block
     def multiple(&blk)
-      Commands::Multiple.new(queries(middlewares)).call(&blk)
+      Commands::Multiple.new(Queries.new(transactions: transaction_queries)).call(&blk)
     end
 
     # Read events from the specific stream or from "all" stream.
@@ -101,7 +105,7 @@ module PgEventstore
     # @raise [PgEventstore::StreamNotFoundError]
     def read(stream, options: {}, middlewares: nil)
       Commands::Read.
-        new(queries(middlewares(middlewares))).
+        new(Queries.new(streams: stream_queries, events: event_queries(middlewares(middlewares)))).
         call(stream, options: { max_count: config.max_count }.merge(options))
     end
 
@@ -120,10 +124,20 @@ module PgEventstore
       PgEventstore.connection(config.name)
     end
 
+    # @return [PgEventstore::StreamQueries]
+    def stream_queries
+      StreamQueries.new(connection)
+    end
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
+
     # @param middlewares [Array<Object<#serialize, #deserialize>>]
-    # @return [PgEventstore::Queries]
-    def queries(middlewares)
-      Queries.new(
+    # @return [PgEventstore::EventQueries]
+    def event_queries(middlewares)
+      EventQueries.new(
         connection,
         EventSerializer.new(middlewares),
         PgResultDeserializer.new(middlewares, config.event_class_resolver)

data/lib/pg_eventstore/commands/append.rb

@@ -14,14 +14,14 @@ module PgEventstore
       def call(stream, *events, options: {})
         raise SystemStreamError, stream if stream.system?
 
-        queries.transaction do
-          stream = queries.find_or_create_stream(stream)
+        queries.transactions.transaction do
+          stream = queries.streams.find_or_create_stream(stream)
           revision = stream.stream_revision
           assert_expected_revision!(revision, options[:expected_revision]) if options[:expected_revision]
           events.map.with_index(1) do |event, index|
-            queries.insert(stream, prepared_event(event, revision + index))
+            queries.events.insert(stream, prepared_event(event, revision + index))
           end.tap do
-            queries.update_stream_revision(stream, revision + events.size)
+            queries.streams.update_stream_revision(stream, revision + events.size)
           end
         end
       end

data/lib/pg_eventstore/commands/multiple.rb

@@ -5,7 +5,7 @@ module PgEventstore
     # @!visibility private
     class Multiple < AbstractCommand
       def call(&blk)
-        queries.transaction do
+        queries.transactions.transaction do
           yield
         end
       end

data/lib/pg_eventstore/commands/read.rb

@@ -15,9 +15,9 @@ module PgEventstore
       # @return [Array<PgEventstore::Event>]
       # @raise [PgEventstore::StreamNotFoundError]
       def call(stream, options: {})
-        stream = queries.find_stream(stream) || raise(StreamNotFoundError, stream) unless stream.all_stream?
+        stream = queries.streams.find_stream(stream) || raise(StreamNotFoundError, stream) unless stream.all_stream?
 
-        queries.stream_events(stream, options)
+        queries.events.stream_events(stream, options)
       end
     end
   end

data/lib/pg_eventstore/queries/event_queries.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'pg_eventstore/query_builders/events_filtering_query'
+
+module PgEventstore
+  # @!visibility private
+  class EventQueries
+    attr_reader :connection, :serializer, :deserializer
+    private :connection, :serializer, :deserializer
+
+    # @param connection [PgEventstore::Connection]
+    # @param serializer [PgEventstore::EventSerializer]
+    # @param deserializer [PgEventstore::PgResultDeserializer]
+    def initialize(connection, serializer, deserializer)
+      @connection = connection
+      @serializer = serializer
+      @deserializer = deserializer
+    end
+
+    # @see PgEventstore::Client#read for more info
+    # @param stream [PgEventstore::Stream]
+    # @param options [Hash]
+    # @return [Array<PgEventstore::Event>]
+    def stream_events(stream, options)
+      exec_params = events_filtering(stream, options).to_exec_params
+      pg_result = connection.with do |conn|
+        conn.exec_params(*exec_params)
+      end
+      deserializer.deserialize_many(pg_result)
+    end
+
+    # @param stream [PgEventstore::Stream] persisted stream
+    # @param event [PgEventstore::Event]
+    # @return [PgEventstore::Event]
+    def insert(stream, event)
+      serializer.serialize(event)
+
+      attributes = event.options_hash.slice(:id, :type, :data, :metadata, :stream_revision, :link_id).compact
+      attributes[:stream_id] = stream.id
+
+      sql = <<~SQL
+        INSERT INTO events (#{attributes.keys.join(', ')}) 
+          VALUES (#{(1..attributes.values.size).map { |n| "$#{n}" }.join(', ')}) 
+          RETURNING *
+      SQL
+
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, attributes.values)
+      end
+      deserializer.without_middlewares.deserialize_one(pg_result).tap do |persisted_event|
+        persisted_event.stream = stream
+      end
+    end
+
+    private
+
+    # @param stream [PgEventstore::Stream]
+    # @param options [Hash]
+    # @param offset [Integer]
+    # @return [PgEventstore::EventsFilteringQuery]
+    def events_filtering(stream, options, offset: 0)
+      return QueryBuilders::EventsFiltering.all_stream_filtering(options, offset: offset) if stream.all_stream?
+
+      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options, offset: offset)
+    end
+  end
+end

data/lib/pg_eventstore/queries/stream_queries.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class StreamQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Finds a stream in the database by the given Stream object
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::Stream, nil] persisted stream
+    def find_stream(stream)
+      builder =
+        SQLBuilder.new.
+          from('streams').
+          where('streams.context = ? AND streams.stream_name = ? AND streams.stream_id = ?', *stream.to_a).
+          limit(1)
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      deserialize(pg_result) if pg_result.ntuples == 1
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::RawStream] persisted stream
+    def create_stream(stream)
+      create_sql = <<~SQL
+        INSERT INTO streams (context, stream_name, stream_id) VALUES ($1, $2, $3) RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(create_sql, stream.to_a)
+      end
+      deserialize(pg_result)
+    end
+
+    # @return [PgEventstore::Stream] persisted stream
+    def find_or_create_stream(stream)
+      find_stream(stream) || create_stream(stream)
+    end
+
+    # @param stream [PgEventstore::Stream] persisted stream
+    # @return [void]
+    def update_stream_revision(stream, revision)
+      connection.with do |conn|
+        conn.exec_params(<<~SQL, [revision, stream.id])
+          UPDATE streams SET stream_revision = $1 WHERE id = $2
+        SQL
+      end
+    end
+
+    private
+
+    # @param pg_result [PG::Result]
+    # @return [PgEventstore::Stream, nil]
+    def deserialize(pg_result)
+      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym))
+    end
+  end
+end

data/lib/pg_eventstore/queries/transaction_queries.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class TransactionQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @return [void]
+    def transaction
+      connection.with do |conn|
+        # We are inside a transaction already - no need to start another one
+        if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
+          next yield
+        end
+
+        conn.transaction do
+          conn.exec("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
+          yield
+        end
+      end
+    rescue PG::TRSerializationFailure, PG::TRDeadlockDetected => e
+      retry if [PG::PQTRANS_IDLE, PG::PQTRANS_UNKNOWN].include?(e.connection.transaction_status)
+      raise
+    end
+  end
+end

data/lib/pg_eventstore/queries.rb

@@ -1,127 +1,22 @@
 # frozen_string_literal: true
 
-require_relative 'query_builders/events_filtering_query'
+require_relative 'queries/transaction_queries'
+require_relative 'queries/event_queries'
+require_relative 'queries/stream_queries'
 
 module PgEventstore
   # @!visibility private
   class Queries
-    attr_reader :connection, :serializer, :deserializer
-    private :connection, :serializer, :deserializer
-
-    # @param connection [PgEventstore::Connection]
-    # @param serializer [PgEventstore::EventSerializer]
-    # @param deserializer [PgEventstore::PgResultDeserializer]
-    def initialize(connection, serializer, deserializer)
-      @connection = connection
-      @serializer = serializer
-      @deserializer = deserializer
-    end
-
-    # @return [void]
-    def transaction
-      connection.with do |conn|
-        # We are inside a transaction already - no need to start another one
-        if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
-          next yield
-        end
-
-        conn.transaction do
-          conn.exec("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
-          yield
-        end
-      end
-    rescue PG::TRSerializationFailure, PG::TRDeadlockDetected => e
-      retry if [PG::PQTRANS_IDLE, PG::PQTRANS_UNKNOWN].include?(e.connection.transaction_status)
-      raise
-    end
-
-    # Finds a stream in the database by the given Stream object
-    # @param stream [PgEventstore::Stream]
-    # @return [PgEventstore::Stream, nil] persisted stream
-    def find_stream(stream)
-      builder =
-        SQLBuilder.new.
-          from('streams').
-          where('streams.context = ? AND streams.stream_name = ? AND streams.stream_id = ?', *stream.to_a).
-          limit(1)
-      pg_result = connection.with do |conn|
-        conn.exec_params(*builder.to_exec_params)
-      end
-      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym)) if pg_result.ntuples == 1
-    end
-
-    # @param stream [PgEventstore::Stream]
-    # @return [PgEventstore::RawStream] persisted stream
-    def create_stream(stream)
-      create_sql = <<~SQL
-        INSERT INTO streams (context, stream_name, stream_id) VALUES ($1, $2, $3) RETURNING *
-      SQL
-      pg_result = connection.with do |conn|
-        conn.exec_params(create_sql, stream.to_a)
-      end
-      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym))
-    end
-
-    # @return [PgEventstore::Stream] persisted stream
-    def find_or_create_stream(stream)
-      find_stream(stream) || create_stream(stream)
-    end
-
-    # @see PgEventstore::Client#read for more info
-    # @param stream [PgEventstore::Stream]
-    # @param options [Hash]
-    # @return [Array<PgEventstore::Event>]
-    def stream_events(stream, options)
-      exec_params = events_filtering(stream, options).to_exec_params
-      pg_result = connection.with do |conn|
-        conn.exec_params(*exec_params)
-      end
-      deserializer.deserialize_many(pg_result)
-    end
-
-    # @param stream [PgEventstore::Stream] persisted stream
-    # @param event [PgEventstore::Event]
-    # @return [PgEventstore::Event]
-    def insert(stream, event)
-      serializer.serialize(event)
-
-      attributes = event.options_hash.slice(:id, :type, :data, :metadata, :stream_revision, :link_id).compact
-      attributes[:stream_id] = stream.id
-
-      sql = <<~SQL
-        INSERT INTO events (#{attributes.keys.join(', ')}) 
-          VALUES (#{(1..attributes.values.size).map { |n| "$#{n}" }.join(', ')}) 
-          RETURNING *
-      SQL
-
-      pg_result = connection.with do |conn|
-        conn.exec_params(sql, attributes.values)
-      end
-      deserializer.without_middlewares.deserialize_one(pg_result).tap do |persisted_event|
-        persisted_event.stream = stream
-      end
-    end
-
-    # @param stream [PgEventstore::Stream] persisted stream
-    # @return [void]
-    def update_stream_revision(stream, revision)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [revision, stream.id])
-          UPDATE streams SET stream_revision = $1 WHERE id = $2
-        SQL
-      end
-    end
-
-    private
-
-    # @param stream [PgEventstore::Stream]
-    # @param options [Hash]
-    # @param offset [Integer]
-    # @return [PgEventstore::EventsFilteringQuery]
-    def events_filtering(stream, options, offset: 0)
-      return QueryBuilders::EventsFiltering.all_stream_filtering(options, offset: offset) if stream.all_stream?
-
-      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options, offset: offset)
-    end
+    include Extensions::OptionsExtension
+
+    # @!attribute events
+    #   @return [PgEventstore::EventQueries, nil]
+    attribute(:events)
+    # @!attribute streams
+    #   @return [PgEventstore::StreamQueries, nil]
+    attribute(:streams)
+    # @!attribute transactions
+    #   @return [PgEventstore::TransactionQueries, nil]
+    attribute(:transactions)
   end
 end

data/lib/pg_eventstore/tasks/setup.rake

@@ -53,6 +53,7 @@ namespace :pg_eventstore do
       conn.exec <<~SQL
         DROP TABLE IF EXISTS public.events;
         DROP TABLE IF EXISTS public.streams;
+        DROP TABLE IF EXISTS public.migrations;
         DROP EXTENSION IF EXISTS "uuid-ossp";
         DROP EXTENSION IF EXISTS pgcrypto;
       SQL

data/lib/pg_eventstore/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgEventstore
-  VERSION = "0.2.1"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_eventstore
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-14 00:00:00.000000000 Z
+date: 2023-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -55,6 +55,7 @@ files:
 - db/initial/tables.sql
 - db/migrations/0_improve_all_stream_indexes.sql
 - db/migrations/1_improve_specific_stream_indexes.sql
+- db/migrations/2_adjust_global_position_index.sql
 - docs/appending_events.md
 - docs/configuration.md
 - docs/events_and_streams.md
@@ -78,6 +79,9 @@ files:
 - lib/pg_eventstore/middleware.rb
 - lib/pg_eventstore/pg_result_deserializer.rb
 - lib/pg_eventstore/queries.rb
+- lib/pg_eventstore/queries/event_queries.rb
+- lib/pg_eventstore/queries/stream_queries.rb
+- lib/pg_eventstore/queries/transaction_queries.rb
 - lib/pg_eventstore/query_builders/events_filtering_query.rb
 - lib/pg_eventstore/rspec/has_option_matcher.rb
 - lib/pg_eventstore/sql_builder.rb