pg 1.3.0.rc2 → 1.3.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '01977a78278505c93856525a241f0f1bd8d4aefbec15c2851ee3acf27f57b22a'
-  data.tar.gz: b570352e689abc3eef0b129b5533bdecf814b0587a9852d9c0137880372c9fdd
+  metadata.gz: 3b18ac1f1e20350b0ecaba8a4ac2f7ce03595832032df15656bec776e5cc7122
+  data.tar.gz: f53771eb5bbd48eaf298f7eecba977a5eeb082dfc59700f0f086151bf646d037
 SHA512:
-  metadata.gz: e4b30c1e706f276d6e623a5171b17084923fb858c7d0f5986b8baba37b3403aa79e9a044ec3c787da99a7fe51d1efb5772ae64512e7df731001ae4e187668392
-  data.tar.gz: a2679e47f258f04b1be5fcb58359a79310e6478293d905745c44e902c21336054c22f4ac5e72f4ce96f533caecb529d377a6f82a976ece74ffc98fe6e0709299
+  metadata.gz: 9a46cb6ccbb650023647a719e9a0c69fedea7534a3c076d7b5708926e3113ac6b1e8e669cd4507e1a6120643c19217c95aff8c30b264842b60ed7b8a504cdb2c
+  data.tar.gz: 2aa5dfdcda711849d777c3825880810422b14af0f513b4086ee6d6b56ffc163992356f1876680437369e3561a297dd6b6802b778ff2a9d33b8611a578d3523f4

data/.github/workflows/source-gem.yml

@@ -113,7 +113,6 @@ jobs:
       - run: bundle install
 
       - run: gem install --local *.gem --verbose
-        continue-on-error: ${{ matrix.ruby == 'truffleruby-head' }}
 
       - name: Run specs
         continue-on-error: ${{ matrix.ruby == 'truffleruby-head' }}

data/ext/pg_connection.c

@@ -968,8 +968,8 @@ static VALUE pgconn_sync_exec_params( int, VALUE *, VALUE );
  * However #async_exec has two advantages:
  *
  * 1. #async_exec can be aborted by signals (like Ctrl-C), while #exec blocks signal processing until the query is answered.
- * 2. Ruby VM gets notified about IO blocked operations.
- *    It can therefore schedule things like garbage collection, while queries are running like in this proposal: https://bugs.ruby-lang.org/issues/14723
+ * 2. Ruby VM gets notified about IO blocked operations and can pass them through <tt>Fiber.scheduler</tt>.
+ *    So only <tt>async_*</tt> methods are compatible to event based schedulers like the async gem.
  */
 static VALUE
 pgconn_sync_exec(int argc, VALUE *argv, VALUE self)
@@ -2208,17 +2208,25 @@ pgconn_notifies(VALUE self)
 }
 
 
-#if !defined(HAVE_RB_IO_WAIT)
+#if defined(HAVE_RB_IO_WAIT)
+
+/* Use our own function and constants names, to avoid conflicts with truffleruby-head on its road to ruby-3.0 compatibility. */
+#define pg_rb_io_wait rb_io_wait
+#define PG_RUBY_IO_READABLE RUBY_IO_READABLE
+#define PG_RUBY_IO_WRITABLE RUBY_IO_WRITABLE
+#define PG_RUBY_IO_PRIORITY RUBY_IO_PRIORITY
+
+#else
 /* For compat with ruby < 3.0 */
 
 typedef enum {
-    RUBY_IO_READABLE = RB_WAITFD_IN,
-    RUBY_IO_WRITABLE = RB_WAITFD_OUT,
-    RUBY_IO_PRIORITY = RB_WAITFD_PRI,
-} rb_io_event_t;
+    PG_RUBY_IO_READABLE = RB_WAITFD_IN,
+    PG_RUBY_IO_WRITABLE = RB_WAITFD_OUT,
+    PG_RUBY_IO_PRIORITY = RB_WAITFD_PRI,
+} pg_rb_io_event_t;
 
 static VALUE
-rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
+pg_rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
 	rb_io_t *fptr;
 	struct timeval waittime;
 	int res;
@@ -2267,7 +2275,7 @@ wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)
 		/* Is the given timeout valid? */
 		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
 			/* Wait for the socket to become readable before checking again */
-			ret = rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE), wait_timeout);
+			ret = pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), wait_timeout);
 		} else {
 			ret = Qfalse;
 		}
@@ -2304,9 +2312,9 @@ pgconn_async_flush(VALUE self)
 		/* wait for the socket to become read- or write-ready */
 		int events;
 		VALUE socket_io = pgconn_socket_io(self);
-		events = RB_NUM2INT(rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE | RUBY_IO_WRITABLE), Qnil));
+		events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
 
-		if (events & RUBY_IO_READABLE)
+		if (events & PG_RUBY_IO_READABLE)
 			pgconn_consume_input(self);
 	}
 	return Qtrue;
@@ -3013,10 +3021,10 @@ pgconn_discard_results(VALUE self)
 		int status;
 
 		/* pgconn_block() raises an exception in case of errors.
-		* To avoid this call rb_io_wait() and PQconsumeInput() without rb_raise().
+		* To avoid this call pg_rb_io_wait() and PQconsumeInput() without rb_raise().
 		*/
 		while( gvl_PQisBusy(conn) ){
-			rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
+			pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
 			if ( PQconsumeInput(conn) == 0 ) {
 				pgconn_close_socket_io(self);
 				return Qfalse;
@@ -3037,7 +3045,7 @@ pgconn_discard_results(VALUE self)
 				int st = gvl_PQgetCopyData(conn, &buffer, 1);
 				if( st == 0 ) {
 					/* would block -> wait for readable data */
-					rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
+					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
 					if ( PQconsumeInput(conn) == 0 ) {
 						pgconn_close_socket_io(self);
 						return Qfalse;
@@ -3076,6 +3084,7 @@ pgconn_discard_results(VALUE self)
  * #exec is an alias for #async_exec which is almost identical to #sync_exec .
  * #sync_exec is implemented on the simpler synchronous command processing API of libpq, whereas
  * #async_exec is implemented on the asynchronous API and on ruby's IO mechanisms.
+ * Only #async_exec is compatible to <tt>Fiber.scheduler</tt> based asynchronous IO processing introduced in ruby-3.0.
  * Both methods ensure that other threads can process while waiting for the server to
  * complete the request, but #sync_exec blocks all signals to be processed until the query is finished.
  * This is most notably visible by a delayed reaction to Control+C.

data/lib/pg/connection.rb

@@ -21,6 +21,13 @@ require 'socket'
 #
 # See the PG::Result class for information on working with the results of a query.
 #
+# Many methods of this class have three variants kind of:
+# 1. #exec - the base method which is an alias to #async_exec .
+#    This is the method that should be used in general.
+# 2. #async_exec - the async aware version of the method, implemented by libpq's async API.
+# 3. #sync_exec - the method version that is implemented by blocking function(s) of libpq.
+#
+# Sync and async version of the method can be switched by Connection.async_api= , however it is not recommended to change the default.
 class PG::Connection
 
 	# The order the options are passed to the ::connect method.
@@ -690,7 +697,7 @@ class PG::Connection
 		#
 		# Raises a PG::Error if the connection fails.
 		def new(*args, **kwargs)
-			conn = PG::Connection.connect_start(*args, **kwargs ) or
+			conn = self.connect_start(*args, **kwargs ) or
 				raise(PG::Error, "Unable to create a new connection")
 
 			raise(PG::ConnectionBad, conn.error_message) if conn.status == PG::CONNECTION_BAD

data/lib/pg/version.rb

@@ -1,4 +1,4 @@
 module PG
 	# Library version
-	VERSION = '1.3.0.rc2'
+	VERSION = '1.3.0.rc3'
 end

data/lib/pg.rb

@@ -63,8 +63,8 @@ module PG
 
 
 	### Convenience alias for PG::Connection.new.
-	def self::connect( *args )
-		return PG::Connection.new( *args )
+	def self::connect( *args, **kwargs )
+		return PG::Connection.new( *args, **kwargs )
 	end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg
 version: !ruby/object:Gem::Version
-  version: 1.3.0.rc2
+  version: 1.3.0.rc3
 platform: ruby
 authors:
 - Michael Granger
@@ -36,7 +36,7 @@ cert_chain:
   d5T9wAD7jW/0seVujw+76/YOJWO3Dft+FQmMBbdd8s3J47HbN9R2mDt6fl6he+X/
   gw==
   -----END CERTIFICATE-----
-date: 2022-01-08 00:00:00.000000000 Z
+date: 2022-01-13 00:00:00.000000000 Z
 dependencies: []
 description: Pg is the Ruby interface to the PostgreSQL RDBMS. It works with PostgreSQL
   9.3 and later.