pg_eventstore 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8c492f46288f9c4c5d3912cad3aba0664bf91693a2273785654e6a96f634668
-  data.tar.gz: 6cbc3ab33fd7d9ed71ae8664ad95b784fffd07ead7d56a7046f481f36eecc531
+  metadata.gz: bc158c2f99fee36514e1902199691dfb93e882ecdebe4738bbcf787fadc8f514
+  data.tar.gz: a70d00d4bdaef48223e35234f01d938a713f9306aa1bfb45bde99733b3654c39
 SHA512:
-  metadata.gz: efe92ab2610b9bbf0e33fc6ed98a7104737ad9f02a7217651b7f7354a7c3b25008a01033b71f7057279dd5ad21846cab3fbd4408941b4f6a6015532651ba40e6
-  data.tar.gz: cf31608048782d34203643b02374ff52afbed8760e0dbbff7e5026c6c518d26f489c396412f8ec88a52fbaf1dbd22a5788feb1873bfc1c59b7cfce8080b8e4b2
+  metadata.gz: bf38d241b001b4244d9fa915d2dfcabec7ac9456aa83832b8d850fe3fd34e48b0ef8b9ef5f0cca91b776124ec3333dea658220f3bd427309b3b1ae09a12714ae
+  data.tar.gz: af5b5e4394ee696790145852ac6a7761728e5cc7e7aca127e6cde112b857e5516b121ac2bb7bf2280e7e66c93cf0823e33bcbe1f258cadbff31d50f83d9972a8

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.2.4] - 2023-12-20
+
+Due to performance issues under certain circumstances, searching by event type was giving bad performance. I decided to extract `type` column from `events` table into separated table. **No breaking changes in public API though.**
+
+**Warning** The migrations this version has, requires you to shut down applications that use `pg_eventstore` and only then run `rake pg_eventstore:migrate`.
+
+## [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

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/db/migrations/3_extract_type_into_separate_table.sql

@@ -0,0 +1,17 @@
+CREATE TABLE public.event_types
+(
+    id              bigserial         NOT NULL,
+    type            character varying NOT NULL
+);
+
+ALTER TABLE ONLY public.events ADD COLUMN event_type_id bigint;
+
+ALTER TABLE ONLY public.event_types
+    ADD CONSTRAINT event_types_pkey PRIMARY KEY (id);
+
+ALTER TABLE ONLY public.events
+    ADD CONSTRAINT events_event_type_fk FOREIGN KEY (event_type_id)
+        REFERENCES public.event_types (id);
+
+CREATE UNIQUE INDEX idx_event_types_type ON public.event_types USING btree (type);
+CREATE INDEX idx_events_event_type_id ON public.events USING btree (event_type_id);

data/db/migrations/4_populate_event_types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+PgEventstore.connection.with do |conn|
+  types = conn.exec('select type from events group by type').to_a.map { |attrs| attrs['type'] }
+  types.each.with_index(1) do |type, index|
+    id = conn.exec_params('SELECT id FROM event_types WHERE type = $1', [type]).to_a.first['id']
+    id ||= conn.exec_params('INSERT INTO event_types (type) VALUES ($1) RETURNING *', [type]).to_a.first['id']
+    conn.exec_params('UPDATE events SET event_type_id = $1 WHERE type = $2 AND event_type_id IS NULL', [id, type])
+    puts "Processed #{index} types of #{types.size}"
+  end
+end

data/db/migrations/5_adjust_indexes.sql

@@ -0,0 +1,6 @@
+CREATE INDEX idx_events_global_position ON public.events USING btree (global_position);
+
+DROP INDEX idx_events_stream_id_and_type_and_revision;
+DROP INDEX idx_events_type_and_stream_id_and_position;
+DROP INDEX idx_events_global_position_including_type;
+DROP INDEX idx_events_type_and_position;

data/db/migrations/6_change_events_event_type_id_null_constraint.sql

@@ -0,0 +1 @@
+ALTER TABLE public.events ALTER COLUMN event_type_id SET NOT NULL;

data/db/migrations/7_change_events_type_constraint.sql

@@ -0,0 +1 @@
+ALTER TABLE public.events ALTER COLUMN type DROP NOT NULL;

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,93 @@
+# 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)
+      options = include_event_types_ids(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, :data, :metadata, :stream_revision, :link_id).compact
+      attributes[:stream_id] = stream.id
+      attributes[:event_type_id] = event_type_queries.find_or_create_type(event.type)
+
+      sql = <<~SQL
+        INSERT INTO events (#{attributes.keys.join(', ')}) 
+          VALUES (#{positional_vars(attributes.values)}) 
+          RETURNING *, $#{attributes.values.size + 1} as type
+      SQL
+
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [*attributes.values, event.type])
+      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
+
+    # Replaces filter by event type strings with filter by event type ids
+    # @param options [Hash]
+    # @return [Hash]
+    def include_event_types_ids(options)
+      options in { filter: { event_types: Array => event_types } }
+      return options unless event_types
+
+      filter = options[:filter].dup
+      filter[:event_type_ids] = event_type_queries.find_event_types(event_types).uniq
+      filter.delete(:event_types)
+      options.merge(filter: filter)
+    end
+
+    # @param array [Array]
+    # @return [String] positional variables, based on array size. Example: "$1, $2, $3"
+    def positional_vars(array)
+      array.size.times.map { |t| "$#{t + 1}" }.join(', ')
+    end
+
+    # @return [PgEventstore::EventTypeQueries]
+    def event_type_queries
+      EventTypeQueries.new(connection)
+    end
+  end
+end

data/lib/pg_eventstore/queries/event_type_queries.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class EventTypeQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param type [String]
+    # @return [Integer] event type's id
+    def find_or_create_type(type)
+      find_type(type) || create_type(type)
+    end
+
+    # @param type [String]
+    # @return [Integer, nil] event type's id
+    def find_type(type)
+      connection.with do |conn|
+        conn.exec_params('SELECT id FROM event_types WHERE type = $1', [type])
+      end.to_a.dig(0, 'id')
+    end
+
+    # @param type [String]
+    # @return [Integer] event type's id
+    def create_type(type)
+      connection.with do |conn|
+        conn.exec_params('INSERT INTO event_types (type) VALUES ($1) RETURNING id', [type])
+      end.to_a.dig(0, 'id')
+    end
+
+    # @param types [Array<String>]
+    # @return [Array<Integer, nil>]
+    def find_event_types(types)
+      connection.with do |conn|
+        conn.exec_params(<<~SQL, [types])
+          SELECT event_types.id, types.type
+            FROM event_types 
+            RIGHT JOIN (
+              SELECT unnest($1::varchar[]) type
+            ) types ON types.type = event_types.type
+        SQL
+      end.to_a.map { |attrs| attrs['id'] }
+    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,41 @@
+# 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
+
+        pg_transaction(conn) do
+          yield
+        end
+      end
+    end
+
+    private
+
+    # @param pg_connection [PG::Connection]
+    # @return [void]
+    def pg_transaction(pg_connection)
+      pg_connection.transaction do
+        pg_connection.exec("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
+        yield
+      end
+    rescue PG::TRSerializationFailure, PG::TRDeadlockDetected
+      retry
+    end
+  end
+end

data/lib/pg_eventstore/queries.rb

@@ -1,127 +1,23 @@
 # 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'
+require_relative 'queries/event_type_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/query_builders/events_filtering_query.rb

@@ -23,8 +23,8 @@ module PgEventstore
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def all_stream_filtering(options, offset: 0)
           event_filter = new
-          options in { filter: { event_types: Array => event_types } }
-          event_filter.add_event_types(event_types)
+          options in { filter: { event_type_ids: Array => event_type_ids } }
+          event_filter.add_event_types(event_type_ids)
           event_filter.add_limit(options[:max_count])
           event_filter.add_offset(offset)
           event_filter.resolve_links(options[:resolve_link_tos])
@@ -41,8 +41,8 @@ module PgEventstore
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def specific_stream_filtering(stream, options, offset: 0)
           event_filter = new
-          options in { filter: { event_types: Array => event_types } }
-          event_filter.add_event_types(event_types)
+          options in { filter: { event_type_ids: Array => event_type_ids } }
+          event_filter.add_event_types(event_type_ids)
           event_filter.add_limit(options[:max_count])
           event_filter.add_offset(offset)
           event_filter.resolve_links(options[:resolve_link_tos])
@@ -58,8 +58,10 @@ module PgEventstore
           SQLBuilder.new.
             select('events.*').
             select('row_to_json(streams.*) as stream').
+            select('event_types.type as type').
             from('events').
             join('JOIN streams ON streams.id = events.stream_id').
+            join('JOIN event_types ON event_types.id = events.event_type_id').
             limit(DEFAULT_LIMIT).
             offset(DEFAULT_OFFSET)
       end
@@ -85,16 +87,16 @@ module PgEventstore
         @sql_builder.where("streams.id = ?", stream.id)
       end
 
-      # @param event_types [Array, nil]
+      # @param event_type_ids [Array<Integer>, nil]
       # @return [void]
-      def add_event_types(event_types)
-        return if event_types.nil?
-        return if event_types.empty?
-
-        sql = event_types.size.times.map do
-          "events.type = ?"
-        end.join(" OR ")
-        @sql_builder.where(sql, *event_types)
+      def add_event_types(event_type_ids)
+        return if event_type_ids.nil?
+        return if event_type_ids.empty?
+
+        sql = event_type_ids.size.times.map do
+          "?"
+        end.join(", ")
+        @sql_builder.where("event_types.id IN (#{sql})", *event_type_ids)
       end
 
       # @param revision [Integer, nil]

data/lib/pg_eventstore/tasks/setup.rake

@@ -31,12 +31,16 @@ namespace :pg_eventstore do
       latest_migration =
         conn.exec('SELECT number FROM migrations ORDER BY number DESC LIMIT 1').to_a.dig(0, 'number') || -1
 
-      Dir["#{migration_files_root}/*.sql"].each do |f_name|
-        number = File.basename(f_name).split('_')[0].to_i
-        next if latest_migration >= number
+      Dir.chdir migration_files_root do
+        Dir["*.{sql,rb}"].each do |f_name|
+          number = File.basename(f_name).split('_')[0].to_i
+          next if latest_migration >= number
 
-        conn.transaction do
-          conn.exec(File.read(f_name))
+          if File.extname(f_name) == '.rb'
+            load f_name
+          else
+            conn.exec(File.read(f_name))
+          end
           conn.exec_params('INSERT INTO migrations (number) VALUES ($1)', [number])
         end
       end
@@ -53,6 +57,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.event_types;
         DROP TABLE IF EXISTS public.migrations;
         DROP EXTENSION IF EXISTS "uuid-ossp";
         DROP EXTENSION IF EXISTS pgcrypto;

data/lib/pg_eventstore/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_eventstore
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-14 00:00:00.000000000 Z
+date: 2023-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -55,6 +55,12 @@ 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
+- db/migrations/3_extract_type_into_separate_table.sql
+- db/migrations/4_populate_event_types.rb
+- db/migrations/5_adjust_indexes.sql
+- db/migrations/6_change_events_event_type_id_null_constraint.sql
+- db/migrations/7_change_events_type_constraint.sql
 - docs/appending_events.md
 - docs/configuration.md
 - docs/events_and_streams.md
@@ -78,6 +84,10 @@ 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/event_type_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