pg_versions 2.0 → 3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9b1174e7cd188f4950927c333ada56e38efa995668e613faac794dfe1a12f99
-  data.tar.gz: 93bef8d80d24f74577c88789291d17c1ad7b585b53aa65ed7b639a6e9bed039d
+  metadata.gz: c7b6354edf3a40a5c96c953a579ce6a8e581933c271722abb90bfee0ce056e9c
+  data.tar.gz: 90e4f121ce0888b6cf2a57f7fe92370be6e7933ef6d4ea5288620f4869bc6e36
 SHA512:
-  metadata.gz: a883f123cb0ba892d37fd27ad9fa795a399c0903719670f011226b638429dd719990c2334d0bac1e65c167493130350df050e3ee6ce10c51f8bb52a9194336e8
-  data.tar.gz: 1daf1d513b2de942cfae39b74c2113a75129ccc2b47e9ed87f97fee20e3dc4b20742d808ff56bd6a4edac6d61a545a116bd7cf4621eebd4ea94ee6ab616fa3ba
+  metadata.gz: a0054bcc270e214fa919c6d9003f99ae85cf0f95c821a0a0267e2256d1627a0a4310a3b4ab90cf1eb349c2700d7b90b38dd86b8de77c48bb241a42c770ec5980
+  data.tar.gz: 0fa50a3c96302bd9e14ea3ba943ab63c70ecf005741cf33fb6181f56c4f22c1e21e4140c325e9a53902ea3b40c22e99a66c59f92fd9eab96bc7655d116a09a95

data/db/migrate/1_create_pg_versions_table.rb

@@ -1,11 +1,11 @@
 class CreatePgVersionsTable < ActiveRecord::Migration[7.0]
 
         def up
-                PgVersions.create_table
+                PgVersions.create_table(ActiveRecord::Base)
         end
 
         def down
-                PgVersions.drop_table
+                PgVersions.drop_table(ActiveRecord::Base)
         end
 
 end

data/lib/pg_versions/pg_versions.rb

@@ -26,94 +26,139 @@
 
 
 require 'set'
+require 'pg'
 
 #TODO: prepared statements?
+#TODO: use ractor instead of thread for event listening
 
 module PgVersions
 
 
 	class InvalidParameters < StandardError; end
+	class ConnectionClosed < StandardError; end
 
 	def self.timestamp_to_integers(input)
 		"to_char(%s, 'YYYYMMDD')::integer || ',' || to_char(%s, 'HH24MISS')::integer || ',' || to_char(%s, 'US')::integer"%[input, input, input]
 	end
 
 
-	def self.with_connection(pg_connection, reset: false, &block)
-		if pg_connection.kind_of? PG::Connection
+	def self.with_connection(pg_connection_param, reset, &block)
+		if pg_connection_param.kind_of? ::PG::Connection
+			if reset
+				pg_connection_param.sync_reset
+				pg_connection_param.exec("select;")
+			end
+			block.call(pg_connection_param)
+		elsif pg_connection_param.respond_to? :call
+			pg_connection_param.call(reset, &block)
+		elsif pg_connection_param.kind_of?(String) or pg_connection_param.kind_of?(Hash)
+			Thread.handle_interrupt(Object => :never) {
+				begin
+					pg_connection = nil
+					Thread.handle_interrupt(Object => :immediate) {
+						pg_connection = ::PG.connect(pg_connection_param)
+						block.call(pg_connection)
+					}
+				ensure
+					pg_connection&.close
+				end
+			}
+		elsif defined?(ActiveRecord) and pg_connection_param.kind_of?(Class) and pg_connection_param <= ActiveRecord::Base
+			pg_connection = pg_connection_param.connection.raw_connection
 			if reset
 				pg_connection.sync_reset
 				pg_connection.exec("select;")
 			end
 			block.call(pg_connection)
-		elsif pg_connection.respond_to? :call
-			pg_connection.call(reset, &block)
-		elsif pg_connection.nil? and defined? ActiveRecord
-			ActiveRecord::Base.connection_pool.with_connection { |ar_connection|
-				block.call(ar_connection.instance_variable_get(:@connection))
-			}
 		else
-			raise InvalidParameters, "Missing connection. Either pass pg connection object or import ActiveRecord."
+			raise InvalidParameters, "Invalid connection parameter (#{pg_connection_param.inspect}). Either pass PG::Connection object, url string, hash, ActiveRecord::Base class (or subclass) or call one of the ActiveRecord methods that come with PgVersions refinement."
 		end
-	end	
+	end
+
+
+	refine ActiveRecord::Base.singleton_class do
+		def bump(*channels)
+			PgVersions::bump(self, *channels)
+		end
+
+		def read(*channels)
+			PgVersions::read(self, *channels)
+		end
+	end
 
 
-	def self.string_to_version(version_str) 
+	def self.string_to_version(version_str)
 		version_str.split(",").map { |str| Integer(str) }
 	end
 
 
-	def self.create_table(connection=nil)
-		PgVersions.with_connection(connection) { |pg_connection|
+	def self.create_table(connection)
+		PgVersions.with_connection(connection, false) { |pg_connection|
 			open(File.dirname(__FILE__)+"/../../create-table.sql") { |sql_file|
 				pg_connection.exec sql_file.read
 			}
 		}
 	end
 
-	def self.drop_table(connection=nil)
-		PgVersions.with_connection(connection) { |pg_connection|
+
+	def self.drop_table(connection)
+		PgVersions.with_connection(connection, false) { |pg_connection|
 			open(File.dirname(__FILE__)+"/../../drop-table.sql") { |sql_file|
 				pg_connection.exec sql_file.read
 			}
 		}
 	end
-	
+
+
+	def self.bump_sql(*channels)
+		channels = [channels].flatten.sort
+		return ""  if channels.size == 0
+		encoder = PG::TextEncoder::QuotedLiteral.new(elements_type: PG::TextEncoder::String.new)
+		quoted_channels = channels.map.with_index { |channel, i| "(#{i},#{encoder.encode(channel)})" }.join(", ")
+		# table-wide share lock is there to mutually exclude table cleaner
+		# clock_timestamp() - this has to be a timestamp after table lock got acquired
+		"
+			LOCK TABLE pg_versions IN ACCESS SHARE MODE;
+			WITH
+				to_bump(i, channel) AS (VALUES #{quoted_channels})
+				, current_instant(ts) AS (VALUES (clock_timestamp()))
+				, updated AS (
+						INSERT INTO pg_versions(channel, instant, counter)
+						SELECT to_bump.channel, (SELECT ts FROM current_instant), 0 FROM to_bump
+						ON CONFLICT (channel) DO UPDATE SET
+							instant = GREATEST(pg_versions.instant, EXCLUDED.instant),
+							counter = CASE WHEN pg_versions.instant < EXCLUDED.instant THEN 0 ELSE pg_versions.counter + 1 END
+						RETURNING channel, instant, pg_versions.counter
+						)
+			SELECT DISTINCT
+				i
+				, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text AS version
+				, pg_notify(updated.channel::text, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text)::text
+			FROM
+				to_bump
+				JOIN updated ON to_bump.channel = updated.channel;
+		"
+	end
+
+
 	#TODO: ensure this is called only once per transaction, or that all bumps occur in the same order in all transactions, to avoid deadlocks
-	def self.bump(*channels, connection: nil)
-		PgVersions.with_connection(connection) { |pg_connection|
-			channels = [channels].flatten.sort
-			return {} if channels.size == 0
-			quoted_channels = channels.map.with_index { |channel, i| "(#{i},'#{pg_connection.escape_string(channel)}')" }.join(", ")
-			# table-wide share lock is there to mutually exclude table cleaner
-			# clock_timestamp() - this has to be a timestamp after table lock got acquired
-			pg_connection.exec("
-				LOCK TABLE pg_versions IN ACCESS SHARE MODE;
-				WITH 
-					to_bump(i, channel) AS (VALUES #{quoted_channels})
-					, current_instant(ts) AS (VALUES (clock_timestamp()))
-					, updated AS (
-							INSERT INTO pg_versions(channel, instant, counter)
-							SELECT to_bump.channel, (SELECT ts FROM current_instant), 0 FROM to_bump
-							ON CONFLICT (channel) DO UPDATE SET
-								instant = GREATEST(pg_versions.instant, EXCLUDED.instant),
-								counter = CASE WHEN pg_versions.instant < EXCLUDED.instant THEN 0 ELSE pg_versions.counter + 1 END
-							RETURNING channel, instant, pg_versions.counter
-							)
-				SELECT DISTINCT
-					i
-					, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text AS version
-					, pg_notify(updated.channel::text, #{timestamp_to_integers('updated.instant')} || ',' || updated.counter::text)::text
-				FROM
-					to_bump
-					JOIN updated ON to_bump.channel = updated.channel;
-			").map { |row| [channels[Integer(row["i"])], string_to_version(row["version"])] }.to_h
+	def self.bump(connection, *channels)
+		channels = [channels].flatten.sort
+		PgVersions.with_connection(connection, false) { |pg_connection|
+			sql = self.bump_sql(*channels)
+			return {} if sql == ""
+			pg_connection.exec(sql) { |result|
+				result.map { |row| [channels[Integer(row["i"])], string_to_version(row["version"])] }.to_h
+			}
 		}
 	end
 
-
-	def self.read(*channels, connection: nil)
-		PgVersions.with_connection(connection) { |pg_connection|
+	
+	#TODO: bump in the same query instead of calling bump
+	#TODO: do we really need to bump though?
+	#TODO: and then, implement read_sql
+	def self.read(connection, *channels)
+		PgVersions.with_connection(connection, false) { |pg_connection|
 			channels = [channels].flatten.sort
 			return {} if channels.size == 0
 			versions = {}
@@ -130,11 +175,12 @@ module PgVersions
 					JOIN pg_versions ON pg_versions.channel = channels.channel
 				ORDER BY
 					i DESC;
-			").each { |row|
-				versions[channels.delete_at(Integer(row["i"]))] = string_to_version(row["version"])
+			") { |result|
+				result.each { |row|
+					versions[channels.delete_at(Integer(row["i"]))] = string_to_version(row["version"])
+				}
 			}
-			#TODO: bump in the same query instead of calling bump
-			versions.merge!(self.bump(channels, connection: pg_connection))  if channels.size > 0
+			versions.merge!(self.bump(pg_connection, channels))  if channels.size > 0
 			versions
 		}
 	end
@@ -149,164 +195,279 @@ module PgVersions
 	end
 
 
+	class ConnectionInner
+		
+		def initialize()
+			@mutex = Mutex.new
+			@command_notify_w = nil
+			@subscriptions = {}
+			@bumps = []
+			@reads = []
+			@closers = []
+			@state = :idle # idle, processing, closing, closed
+		end
 
-	class ConnectionThread
 
-		class Closing < StandardError
-			attr_reader :retpipe
-			def initialize(retpipe)
-				@retpipe = retpipe
+		def process
+			Thread.handle_interrupt(Object => :never) do
+				command_notify_r = nil
+				@mutex.synchronize {
+					case @state
+					when :idle
+						@state = :processing
+					when :processing
+						raise "Attempt to run processing on a connection that is already being processed"
+					when :closing, :closed
+						return
+					end
+				}
+				begin
+					command_notify_r, @command_notify_w = IO.pipe					
+					Thread.handle_interrupt(Object => :immediate) {
+						yield command_notify_r
+					}
+				ensure
+					@mutex.synchronize {
+						command_notify_r&.close
+						@command_notify_w&.close
+						@command_notify_w = nil
+						case @state
+						when :idle, :closed
+							raise "'processor exit in #{@state} state. Please inform the developer of this gem."
+						when :processing
+							@state = :idle
+						when :closing
+							@state = :closed
+							@closers.each { |closer|
+								closer.push true
+							}
+						end
+					}
+				end
 			end
 		end
 
+		
+		def wake_processor
+			@command_notify_w&.write('!')
+			@command_notify_w&.flush
+		end
 
-		attr_reader :status
 
-		def initialize(connection)
-			retry_on_exceptions = [ PG::ConnectionBad, PG::UnableToSend ]
-			retry_on_exceptions << ActiveRecord::ConnectionNotEstablished  if defined? ActiveRecord
+		def get_channels
+			@mutex.synchronize {
+				return @subscriptions.keys
+			}
+		end
 
-			@subscribers = Hash.new { |h,k| h[k] = Set.new }
-			@status = :disconnected
 
-			@thread_requests_mutex = Mutex.new
-			@thread_requests = []
-			thread_requests_notify_r, @thread_requests_notify_w = IO.pipe
+		def notify(channel, version)
+			@mutex.synchronize {
+				(@subscriptions[channel] or []).each { |subscriber|
+					subscriber.notify({ channel => version })
+				}
+			}
+		end
 
-			@thread = Thread.new {
-				reset_connection = false
-				retry_delay = 0
-				begin
-					PgVersions.with_connection(connection, reset: reset_connection) do |pg_connection|
-						
-						@status = :connected
-						retry_delay = 0
 
-						@subscribers.each_key { |channel|
-							listen(pg_connection, channel)
-						}
-						read(pg_connection, @subscribers.keys).each_pair { |channel, version|
-							#p channel, version
-							@subscribers[channel].each { |subscriber|
-								subscriber.notify({ channel => version })
-							}
-						}
+		def taking_bumps
+			@mutex.synchronize {
+				yield @bumps
+				@bumps = []
+			}
+		end
 
-						loop {
-							@thread_requests_mutex.synchronize { 
-								@thread_requests.each { |function, retpipe, params|
-									raise Closing, retpipe  if function == :stop
-									retpipe << send(function, pg_connection, *params)
-								}
-								@thread_requests.clear
-							}
 
-							while notification = pg_connection.notifies
-								channel, payload = notification[:relname], notification[:extra]
-								@subscribers[channel].each { |subscriber|
-									subscriber.notify({ channel => PgVersions.string_to_version(payload) })
-								}
-							end
+		def taking_reads
+			@mutex.synchronize {
+				yield @reads
+				@reads = []
+			}
+		end
 
-							#TODO: handle errors
-							reads,_writes,_errors = IO::select([pg_connection.socket_io, thread_requests_notify_r])
-							
-							if reads.include?(pg_connection.socket_io)
-								pg_connection.consume_input
-							end
 
-							if reads.include?(thread_requests_notify_r)
-								thread_requests_notify_r.read(1)
-							end
-						}
-					rescue Closing => e
-						e.retpipe << true
-					end
-				rescue *retry_on_exceptions => e
-					reset_connection = true
-					@status = :disconnected
-					$stderr.puts "Pg connection failed. Retrying in #{retry_delay/1000.0}s."
-					sleep retry_delay/1000.0
-					retry_delay = { 0=>100, 100=>1000, 1000=>2000, 2000=>2000 }[retry_delay]
-					retry
-				end
-			} 
-			@thread.abort_on_exception = true
+		def bump(channels)
+			result = Queue.new
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				@bumps << [result, channels]
+			}
+			wake_processor
+			result.pop
 		end
 
-		private def listen(pg_connection, channel)
-			pg_connection.exec("LISTEN #{PG::Connection.quote_ident(channel)}")
+
+		def bump_nonblock(channels)
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				@bumps << [nil, channels]
+			}
+			wake_processor
+			nil
 		end
 
-		private def unlisten(pg_connection, channel)
-			pg_connection.exec("UNLISTEN #{PG::Connection.quote_ident(channel)}")
+
+		def read(channels)
+			result = Queue.new
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				@reads << [result, channels]
+			}
+			wake_processor
+			result.pop
 		end
 
-		private def subscribe(pg_connection, subscriber, channels)
-			channels.each { |channel|
-				@subscribers[channel] << subscriber
-				listen(pg_connection, channel)  if @subscribers[channel].size == 1
+
+		def subscribe(subscriber, channels)
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				channels.each { |channel|
+					@subscriptions[channel] = []  if @subscriptions[channel].nil?
+					@subscriptions[channel].push(subscriber)
+				}
 			}
-			subscriber.notify(PgVersions.read(channels, connection: pg_connection))
+			subscriber.notify(read(channels))  # this runs wake_processor, so not doing it explicitly
 			true
 		end
-		
-		private def unsubscribe(pg_connection, subscriber, channels)
-			channels.each { |channel|
-				@subscribers[channel].delete(subscriber)
-				if @subscribers[channel].size == 0
-					unlisten(pg_connection, channel)
-					@subscribers.delete(channel)
-				end
+
+
+		def unsubscribe(subscriber, channels)
+			@mutex.synchronize {
+				raise ConnectionClosed  if @state == :closing || @state == :closed
+				channels.each { |channel|
+					@subscriptions[channel].delete(subscriber)
+					@subscriptions.delete(channel)  if @subscriptions[channel].size == 0
+				}
 			}
+			wake_processor
 			true
 		end
 
-		private def read(pg_connection, channels)
-			PgVersions.read(channels, connection: pg_connection)
-		end
 
-		private def bump(pg_connection, channels)
-			PgVersions.bump(channels, connection: pg_connection)
+		def is_closing
+			@mutex.synchronize {
+				return @state == :closing
+			}
 		end
 
-		def request(function, *params)
-			request_nonblock(function, *params).pop
-		end
 
-		def request_nonblock(function, *params)
-			retpipe = Queue.new
-			@thread_requests_mutex.synchronize {
-				@thread_requests.push [function, retpipe, params]
+		def close
+			result = Queue.new
+			@mutex.synchronize {
+				case @state
+				when :idle
+					@state = :closed
+					return
+				when :processing 
+					@state = :closing
+					@closers << result
+					wake_processor
+				when :closing
+					@closers << result
+				when :closed
+					return
+				end
 			}
-			@thread_requests_notify_w.write('!')
-			retpipe
+			result.pop
 		end
-		
+
 	end
 
+
 	class Connection
-		
-		def initialize(connection=nil)
-			@connection_thread = ConnectionThread.new(connection)
+
+		def initialize()
+			@inner = ConnectionInner.new
+		end
+
+
+		def process(connection_param=nil, autoreconnect=true, &block)
+			raise "Both 'connection_param' and a block were given. Don't know which to use."  if !connection_param.nil? and !block.nil?
+			connection_param ||= block
+
+			retry_on_exceptions = [ ::PG::ConnectionBad, ::PG::UnableToSend ]
+			retry_delay = 0
+			
+			@inner.process do |notification_r|
+				raise if not notification_r
+				PgVersions.with_connection(connection_param, true) do |pg_connection|
+
+					listening_to_channels = @inner.get_channels
+					listening_to_channels.each { |channel|
+						pg_connection.exec("LISTEN #{::PG::Connection.quote_ident(channel)}")
+					}
+					PgVersions.read(pg_connection, listening_to_channels).each { |channel, version|
+						@inner.notify(channel, version)
+					}
+
+					loop {
+						channels_to_listen_to = @inner.get_channels
+						(listening_to_channels - channels_to_listen_to).each { |removed_channel| 
+							pg_connection.exec("UNLISTEN #{::PG::Connection.quote_ident(removed_channel)}")
+						}
+						(channels_to_listen_to - listening_to_channels).each { |added_channel| 
+							pg_connection.exec("LISTEN #{::PG::Connection.quote_ident(added_channel)}")
+						}
+						listening_to_channels = channels_to_listen_to
+
+						@inner.taking_bumps { |bumps|
+							channels_to_bump = bumps.map(&:last).flatten.uniq
+							bumped_versions = PgVersions.bump(pg_connection, channels_to_bump)
+							bumps.each { |bumper, channels|
+								bumper.push bumped_versions.slice(*channels)  if not bumper.nil?
+							}
+						}
+
+						@inner.taking_reads { |reads|
+							channels_to_read = reads.map(&:last).uniq
+							read_versions = PgVersions.read(pg_connection, channels_to_read)
+							reads.each { |reader, channels|
+								reader.push read_versions.slice(*channels)
+							}
+						}
+
+						break if @inner.is_closing
+
+						while notification = pg_connection.notifies
+							channel, payload = notification[:relname], notification[:extra]
+							@inner.notify(channel, PgVersions.string_to_version(payload))
+						end
+
+						#TODO: handle errors
+						reads,_writes,_errors = IO::select([pg_connection.socket_io, notification_r])
+						pg_connection.consume_input  if reads.include?(pg_connection.socket_io)
+						notification_r.read(1)  if reads.include?(notification_r)  #TODO: read everything that can be read here
+
+					}
+				end
+			rescue *retry_on_exceptions => error
+				raise  if connection_param.kind_of?(::PG::Connection)  or  !autoreconnect
+				return if @inner.is_closing
+				$stderr.puts "Pg connection failed (retrying in #{retry_delay/1000.0}s):\n\t#{error.message}"
+				sleep retry_delay/1000.0
+				retry_delay = { 0=>100, 100=>1000, 1000=>2000, 2000=>2000 }[retry_delay]
+				retry
+			end
 		end
 
-		def close()
-			@connection_thread.request(:stop)
+
+		def close
+			@inner.close
 		end
 
+
 		def bump(*channels)
-			@connection_thread.request(:bump, channels)
+			@inner.bump(channels)
 		end
 
 
 		def read(*channels)
-			@connection_thread.request(:read, channels)
+			@inner.read(channels)
 		end
 
 
-		def subscribe(*channels, known: {})
-			subscription = Subscription.new(@connection_thread)
+		def subscribe(*channels, known: {}, batch_delay: 0.01)
+			subscription = Subscription.new(@inner, batch_delay)
 			subscription.subscribe([channels].flatten, known: known)
 			if block_given?
 				Thread.handle_interrupt(Object => :never) {
@@ -324,15 +485,23 @@ module PgVersions
 		end
 
 
+		alias_method :each, def for_each_notification(*channels, known: {}, batch_delay: 0.01, &block)
+			subscribe(*channels, known: known, batch_delay: batch_delay) { |subscription|
+				subscription.for_each_notification(&block)
+			}
+		end
+
+
 		class Subscription
 
-			def initialize(connection_thread)
-				@connection_thread = connection_thread
+			def initialize(inner, batch_delay)
+				@inner = inner
+				@batch_delay = batch_delay
 				@notifications = Queue.new
 				@already_known_versions = Hash.new { |h,k| h[k] = [] }
 				@channels = Hash.new(0)
 			end
-			
+
 
 			def subscribe(channels, known: {})
 				update_already_known_versions(known)
@@ -341,10 +510,10 @@ module PgVersions
 					(@channels[channel] += 1) == 1
 				}
 				if channels.size > 0
-					@connection_thread.request(:subscribe, self, channels)
+					@inner.subscribe(self, channels)
 				end
 			end
-			
+
 
 			def unsubscribe(*channels)
 				channels = [channels].flatten
@@ -354,13 +523,13 @@ module PgVersions
 					@channels.delete(channel)  if @channels[channel] == 0
 					not @channels.has_key?(channel)
 				}
-				@connection_thread.request(:unsubscribe, self, channels)
+				@inner.unsubscribe(self, channels)
 			end
 
 
 			def read(*channels, notify: false)
 				channels = @channels.keys  if channels.size == 0
-				versions = @connection_thread.request(:read, channels)
+				versions = @inner.read(channels)
 				update_already_known_versions(versions)  if not notify
 				versions
 			end
@@ -368,34 +537,39 @@ module PgVersions
 
 			def bump(*channels, notify: false)
 				channels = @channels.keys  if channels.size == 0
-				versions = @connection_thread.request(:bump, channels)
+				versions = @inner.bump(channels)
 				update_already_known_versions(versions)  if not notify
 				versions
 			end
 
 
 			#TODO: make this resume-able after forced exception
-			def wait(new_already_known_versions = {})
+			def wait(new_already_known_versions = {}, batch_delay: nil)
+				batch_delay = @batch_delay  if batch_delay.nil?
 				update_already_known_versions(new_already_known_versions)
 				loop {
-					versions = @notifications.shift
-					return nil  if not versions #termination
-					changed_versions = versions.to_a.map { |channel, version|
-						if (@already_known_versions[channel] <=> version) == -1
-							@already_known_versions[channel] = version
-							[channel, version]
-						end
-					}.compact.to_h
+					events = [@notifications.shift]
+					sleep batch_delay  if batch_delay
+					events << @notifications.shift  while not @notifications.empty?
+					changed_versions = {}
+					events.each { |versions|
+						return nil  if not versions #termination
+						versions.each { |channel, version|
+							if (@already_known_versions[channel] <=> version) == -1
+								@already_known_versions[channel] = version
+								changed_versions[channel] = version
+							end
+						}
+					}
 					if changed_versions.size > 0
 						return Notification.new(changed_versions, @already_known_versions.dup)
 					end
 				}
 			end
 
-
-			def each(new_already_known_versions = {})
+			alias_method :each, def for_each_notification(new_already_known_versions = {}, batch_delay: nil)
 				update_already_known_versions(new_already_known_versions)
-				while notification = wait()
+				while notification = wait(batch_delay: batch_delay)
 					yield notification
 				end
 			end
@@ -408,7 +582,7 @@ module PgVersions
 
 			def drop
 				@notifications << nil
-				@connection_thread.request_nonblock(:unsubscribe, self, @channels.keys)
+				@inner.unsubscribe(self, @channels.keys)  if @channels.keys.size > 0
 				#TODO: what to do if this object gets used after drop?
 			end
 

data/lib/pg_versions/version.rb

@@ -1,3 +1,3 @@
 module PgVersions
-	VERSION = "2.0"
+	VERSION = "3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_versions
 version: !ruby/object:Gem::Version
-  version: '2.0'
+  version: '3.0'
 platform: ruby
 authors:
 - yunta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-08 00:00:00.000000000 Z
+date: 2025-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Persistent timestamped postgres notification library