pg 1.3.3 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b92ccb2d1b40d1641f55960ab8c290cd918d1f5caf21d8a434cfed4c32a3a2c
-  data.tar.gz: 15ab0a988b2b70690bf074c078f44183e76e1cdfc99cabc818073366c2a07292
+  metadata.gz: 0bb3782224d0c471417ceaa47d1355d5a06be2590fb3671fde73882346db0c5c
+  data.tar.gz: cd728b238d0b174f02a31c38afbd990177f81eec8516a1c953ee7bade1ddb4c6
 SHA512:
-  metadata.gz: 571cb50a99c5638e9e0819baae243d91cee56cb953a2037b07446e2bceb243d3b94084f803bc3bbba9acc5e5582401d19571a4f04094ad0e4ac5e71a077580e6
-  data.tar.gz: 6b2e02994f1713004f282c74fcf2a970b8e750553cfc740805bbd47b13c53a3e41ac3de622c905c0ac920343c2672c2f9a3a2d11827c70e1944ce9c25c46377a
+  metadata.gz: d7b3ad8293281fb830274dc0e3d6e3c59c1dca85ea4f112f0aaf3a7629f61e315747f1e6ecad96e7a9528d42eeb3baafb819b7360d02acfc636ae7cb2d24ef42
+  data.tar.gz: f2476f2c7b1950346adf87c3675b838b9c57c909d6d787b50f4cf418ccb51296a02677faac7910378a665daa087f2aa552375f72ca42ba428e539cf07e80392c

data/History.rdoc

@@ -1,3 +1,38 @@
+== v1.3.5 [2022-03-31] Lars Kanis <lars@greiz-reinsdorf.de>
+
+Bugfixes:
+
+- Handle PGRES_COMMAND_OK in pgresult_stream_any. #447
+  Fixes usage when trying to stream the result of a procedure call that returns no results.
+
+Enhancements:
+
+- Rename BasicTypeRegistry#define_default_types to #register_default_types to use a more consistent terminology.
+  Keeping define_default_types for compatibility.
+- BasicTypeRegistry: return self instead of objects by accident.
+  This allows call chaining.
+- Add some April fun. #449
+
+Documentation:
+- Refine documentation of conn.socket_io and conn.connect_poll
+
+
+== v1.3.4 [2022-03-10] Lars Kanis <lars@greiz-reinsdorf.de>
+
+Bugfixes:
+
+- Don't leak IO in case of connection errors. #439
+  Previously it was kept open until the PG::Connection was garbage collected.
+- Fix a performance regession in conn.get_result noticed in single row mode. #442
+- Fix occasional error Errno::EBADF (Bad file descriptor) while connecting. #444
+- Fix compatibility of res.stream_each* methods with Fiber.scheduler. #446
+- Remove FL_TEST and FL_SET, which are MRI-internal. #437
+
+Enhancements:
+
+- Allow pgresult_stream_any to be used by sequel_pg. #443
+
+
 == v1.3.3 [2022-02-22] Lars Kanis <lars@greiz-reinsdorf.de>
 
 Bugfixes:

data/ext/extconf.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 require 'pp'
 require 'mkmf'
 
@@ -167,3 +169,32 @@ end
 create_header()
 create_makefile( "pg_ext" )
 
+
+def message!(important_message)
+	message important_message
+	if !$stdout.tty? && File.chardev?('/dev/tty')
+		File.open('/dev/tty', 'w') do |tty|
+			tty.print important_message
+		end
+	end
+rescue
+end
+
+if "2022-04-01" == Time.now.strftime("%Y-%m-%d")
+	message! <<-EOM
+===================================================================
+HEADS UP! Prepare for pg-1.4.2022 ! 🎉🎉🎉
+
+Now that psycopg3 has most of the features of ruby-pg, we plan to
+switch to using it as our foundation for the next pg release.
+It will run through pycall and requires a working python setup.
+This will minimize our development and maintenance efforts, since
+it allows us to use one and the same code base for both programming
+languages - ruby and python. 👏😃
+
+And we follow the recent merge of the Django and Rails teams! ❤️
+
+Stay up-to-date at https://github.com/ged/ruby-pg/issues/449
+===================================================================
+EOM
+end

data/ext/pg.h

@@ -344,6 +344,7 @@ void pg_typemap_compact                                _(( void * ));
 
 PGconn *pg_get_pgconn                                  _(( VALUE ));
 t_pg_connection *pg_get_connection                     _(( VALUE ));
+VALUE pgconn_block                                     _(( int, VALUE *, VALUE ));
 
 VALUE pg_new_result                                    _(( PGresult *, VALUE ));
 VALUE pg_new_result_autoclear                          _(( PGresult *, VALUE ));

data/ext/pg_connection.c

@@ -450,17 +450,18 @@ pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
  *   the asynchronous connection is ready
  *
  * Example:
- *   conn = PG::Connection.connect_start("dbname=mydatabase")
- *   socket = conn.socket_io
+ *   require "io/wait"
+ *
+ *   conn = PG::Connection.connect_start(dbname: 'mydatabase')
  *   status = conn.connect_poll
  *   while(status != PG::PGRES_POLLING_OK) do
  *     # do some work while waiting for the connection to complete
  *     if(status == PG::PGRES_POLLING_READING)
- *       if(not select([socket], [], [], 10.0))
+ *       unless conn.socket_io.wait_readable(10.0)
  *         raise "Asynchronous connection timed out!"
  *       end
  *     elsif(status == PG::PGRES_POLLING_WRITING)
- *       if(not select([], [socket], [], 10.0))
+ *       unless conn.socket_io.wait_writable(10.0)
  *         raise "Asynchronous connection timed out!"
  *       end
  *     end
@@ -475,9 +476,7 @@ pgconn_connect_poll(VALUE self)
 	PostgresPollingStatusType status;
 	status = gvl_PQconnectPoll(pg_get_pgconn(self));
 
-	if ( status == PGRES_POLLING_FAILED ) {
-		pgconn_close_socket_io(self);
-	}
+	pgconn_close_socket_io(self);
 
 	return INT2FIX((int)status);
 }
@@ -556,9 +555,7 @@ pgconn_reset_poll(VALUE self)
 	PostgresPollingStatusType status;
 	status = gvl_PQresetPoll(pg_get_pgconn(self));
 
-	if ( status == PGRES_POLLING_FAILED ) {
-		pgconn_close_socket_io(self);
-	}
+	pgconn_close_socket_io(self);
 
 	return INT2FIX((int)status);
 }
@@ -822,13 +819,15 @@ pgconn_socket(VALUE self)
  * call-seq:
  *    conn.socket_io() -> IO
  *
- * Fetch a memorized IO object created from the Connection's underlying socket.
- * This object can be used for IO.select to wait for events while running
- * asynchronous API calls.
+ * Fetch an IO object created from the Connection's underlying socket.
+ * This object can be used per <tt>socket_io.wait_readable</tt>, <tt>socket_io.wait_writable</tt> or for <tt>IO.select</tt> to wait for events while running asynchronous API calls.
+ * <tt>IO#wait_*able</tt> is is <tt>Fiber.scheduler</tt> compatible in contrast to <tt>IO.select</tt>.
+ *
+ * The IO object can change while the connection is established, but is memorized afterwards.
+ * So be sure not to cache the IO object, but repeat calling <tt>conn.socket_io</tt> instead.
  *
- * Using this instead of #socket avoids the problem of the underlying connection
- * being closed by Ruby when an IO created using <tt>IO.for_fd(conn.socket)</tt>
- * goes out of scope. In contrast to #socket, it also works on Windows.
+ * Using this method also works on Windows in contrast to using #socket .
+ * It also avoids the problem of the underlying connection being closed by Ruby when an IO created using <tt>IO.for_fd(conn.socket)</tt> goes out of scope.
  */
 static VALUE
 pgconn_socket_io(VALUE self)
@@ -2343,21 +2342,12 @@ pg_rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
 static void *
 wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
 {
-	VALUE socket_io;
 	VALUE ret;
 	void *retval;
 	struct timeval aborttime={0,0}, currtime, waittime;
 	VALUE wait_timeout = Qnil;
 	PGconn *conn = pg_get_pgconn(self);
 
-	socket_io = pgconn_socket_io(self);
-
-	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if ( PQconsumeInput(conn) == 0 ) {
-		pgconn_close_socket_io(self);
-		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
-	}
-
 	if ( ptimeout ) {
 		gettimeofday(&currtime, NULL);
 		timeradd(&currtime, ptimeout, &aborttime);
@@ -2372,6 +2362,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) ){
+			VALUE socket_io = pgconn_socket_io(self);
 			/* Wait for the socket to become readable before checking again */
 			ret = pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), wait_timeout);
 		} else {
@@ -2984,7 +2975,7 @@ get_result_readable(PGconn *conn)
  * If +true+ is returned, +conn.is_busy+ will return +false+
  * and +conn.get_result+ will not block.
  */
-static VALUE
+VALUE
 pgconn_block( int argc, VALUE *argv, VALUE self ) {
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
@@ -3072,7 +3063,8 @@ pgconn_async_get_last_result(VALUE self)
 	for(;;) {
 		int status;
 
-		pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
+		/* wait for input (without blocking) before reading each result */
+		wait_socket_readable(self, NULL, get_result_readable);
 
 		cur = gvl_PQgetResult(conn);
 		if (cur == NULL)

data/ext/pg_record_coder.c

@@ -344,10 +344,12 @@ record_isspace(char ch)
  *   oids = conn.exec( "SELECT (NULL::complex).*" )
  *   # Build a type map (PG::TypeMapByColumn) for decoding the "complex" type
  *   dtm = PG::BasicTypeMapForResults.new(conn).build_column_map( oids )
- *   # Register a record decoder for decoding our type "complex"
- *   PG::BasicTypeRegistry.register_coder(PG::TextDecoder::Record.new(type_map: dtm, name: "complex"))
- *   # Apply the basic type registry to all results retrieved from the server
- *   conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn)
+ *   # Build a type map and populate with basic types
+ *   btr = PG::BasicTypeRegistry.new.register_default_types
+ *   # Register a new record decoder for decoding our type "complex"
+ *   btr.register_coder(PG::TextDecoder::Record.new(type_map: dtm, name: "complex"))
+ *   # Apply our basic type registry to all results retrieved from the server
+ *   conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn, registry: btr)
  *   # Now queries decode the "complex" type (and many basic types) automatically
  *   conn.exec("SELECT * FROM my_table").to_a
  *   # => [{"v1"=>[2.0, 3.0], "v2"=>[4.0, 5.0]}, {"v1"=>[6.0, 7.0], "v2"=>[8.0, 9.0]}]

data/ext/pg_result.c

@@ -1383,7 +1383,7 @@ pgresult_type_map_get(VALUE self)
 
 
 static void
-yield_hash(VALUE self, int ntuples, int nfields)
+yield_hash(VALUE self, int ntuples, int nfields, void *data)
 {
 	int tuple_num;
 	t_pg_result *this = pgresult_get_this(self);
@@ -1397,7 +1397,7 @@ yield_hash(VALUE self, int ntuples, int nfields)
 }
 
 static void
-yield_array(VALUE self, int ntuples, int nfields)
+yield_array(VALUE self, int ntuples, int nfields, void *data)
 {
 	int row;
 	t_pg_result *this = pgresult_get_this(self);
@@ -1417,7 +1417,7 @@ yield_array(VALUE self, int ntuples, int nfields)
 }
 
 static void
-yield_tuple(VALUE self, int ntuples, int nfields)
+yield_tuple(VALUE self, int ntuples, int nfields, void *data)
 {
 	int tuple_num;
 	t_pg_result *this = pgresult_get_this(self);
@@ -1436,8 +1436,9 @@ yield_tuple(VALUE self, int ntuples, int nfields)
 	}
 }
 
-static VALUE
-pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
+/* Non-static, and data pointer for use by sequel_pg */
+VALUE
+pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int, void*), void* data)
 {
 	t_pg_result *this;
 	int nfields;
@@ -1456,6 +1457,7 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
 
 		switch( PQresultStatus(pgresult) ){
 			case PGRES_TUPLES_OK:
+			case PGRES_COMMAND_OK:
 				if( ntuples == 0 )
 					return self;
 				rb_raise( rb_eInvalidResultStatus, "PG::Result is not in single row mode");
@@ -1465,7 +1467,12 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
 				pg_result_check( self );
 		}
 
-		yielder( self, ntuples, nfields );
+		yielder( self, ntuples, nfields, data );
+
+		if( gvl_PQisBusy(pgconn) ){
+			/* wait for input (without blocking) before reading each result */
+			pgconn_block( 0, NULL, this->connection );
+		}
 
 		pgresult = gvl_PQgetResult(pgconn);
 		if( pgresult == NULL )
@@ -1516,7 +1523,7 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
 static VALUE
 pgresult_stream_each(VALUE self)
 {
-	return pgresult_stream_any(self, yield_hash);
+	return pgresult_stream_any(self, yield_hash, NULL);
 }
 
 /*
@@ -1532,7 +1539,7 @@ pgresult_stream_each(VALUE self)
 static VALUE
 pgresult_stream_each_row(VALUE self)
 {
-	return pgresult_stream_any(self, yield_array);
+	return pgresult_stream_any(self, yield_array, NULL);
 }
 
 /*
@@ -1549,7 +1556,7 @@ pgresult_stream_each_tuple(VALUE self)
 	/* allocate VALUEs that are shared between all streamed tuples */
 	ensure_init_for_tuple(self);
 
-	return pgresult_stream_any(self, yield_tuple);
+	return pgresult_stream_any(self, yield_tuple, NULL);
 }
 
 /*

data/ext/pg_tuple.c

@@ -471,10 +471,7 @@ pg_tuple_dump(VALUE self)
 	values = rb_ary_new4(this->num_fields, &this->values[0]);
 	a = rb_ary_new3(2, field_names, values);
 
-	if (FL_TEST(self, FL_EXIVAR)) {
-		rb_copy_generic_ivar(a, self);
-		FL_SET(a, FL_EXIVAR);
-	}
+        rb_copy_generic_ivar(a, self);
 
 	return a;
 }
@@ -542,10 +539,7 @@ pg_tuple_load(VALUE self, VALUE a)
 
 	RTYPEDDATA_DATA(self) = this;
 
-	if (FL_TEST(a, FL_EXIVAR)) {
-		rb_copy_generic_ivar(self, a);
-		FL_SET(self, FL_EXIVAR);
-	}
+        rb_copy_generic_ivar(self, a);
 
 	return self;
 }

data/lib/pg/basic_type_registry.rb

@@ -22,7 +22,7 @@ require 'pg' unless defined?( PG )
 #   end
 #
 #   conn = PG.connect
-#   regi = PG::BasicTypeRegistry.new.define_default_types
+#   regi = PG::BasicTypeRegistry.new.register_default_types
 #   regi.register_type(0, 'inet', InetEncoder, InetDecoder)
 #   conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn, registry: regi)
 class PG::BasicTypeRegistry
@@ -184,6 +184,7 @@ class PG::BasicTypeRegistry
 		name = coder.name || raise(ArgumentError, "name of #{coder.inspect} must be defined")
 		h[:encoder][name] = coder if coder.respond_to?(:encode)
 		h[:decoder][name] = coder if coder.respond_to?(:decode)
+		self
 	end
 
 	# Register the given +encoder_class+ and/or +decoder_class+ for casting a PostgreSQL type.
@@ -193,6 +194,7 @@ class PG::BasicTypeRegistry
 	def register_type(format, name, encoder_class, decoder_class)
 		register_coder(encoder_class.new(name: name, format: format)) if encoder_class
 		register_coder(decoder_class.new(name: name, format: format)) if decoder_class
+		self
 	end
 
 	# Alias the +old+ type to the +new+ type.
@@ -205,10 +207,11 @@ class PG::BasicTypeRegistry
 				@coders_by_name[format][ende].delete(new)
 			end
 		end
+		self
 	end
 
 	# Populate the registry with all builtin types of ruby-pg
-	def define_default_types
+	def register_default_types
 		register_type 0, 'int2', PG::TextEncoder::Integer, PG::TextDecoder::Integer
 		alias_type    0, 'int4', 'int2'
 		alias_type    0, 'int8', 'int2'
@@ -281,8 +284,10 @@ class PG::BasicTypeRegistry
 		self
 	end
 
+	alias define_default_types register_default_types
+
 	# @private
-	DEFAULT_TYPE_REGISTRY = PG::BasicTypeRegistry.new.define_default_types
+	DEFAULT_TYPE_REGISTRY = PG::BasicTypeRegistry.new.register_default_types
 
 	# Delegate class method calls to DEFAULT_TYPE_REGISTRY
 	class << self

data/lib/pg/connection.rb

@@ -612,9 +612,6 @@ class PG::Connection
 	alias async_cancel cancel
 
 	private def async_connect_or_reset(poll_meth)
-		# Now grab a reference to the underlying socket so we know when the connection is established
-		socket = socket_io
-
 		# Track the progress of the connection, waiting for the socket to become readable/writable before polling it
 		poll_status = PG::PGRES_POLLING_WRITING
 		until poll_status == PG::PGRES_POLLING_OK ||
@@ -623,18 +620,22 @@ class PG::Connection
 			# If the socket needs to read, wait 'til it becomes readable to poll again
 			case poll_status
 			when PG::PGRES_POLLING_READING
-				socket.wait_readable
+				socket_io.wait_readable
 
 			# ...and the same for when the socket needs to write
 			when PG::PGRES_POLLING_WRITING
-				socket.wait_writable
+				socket_io.wait_writable
 			end
 
 			# Check to see if it's finished or failed yet
 			poll_status = send( poll_meth )
 		end
 
-		raise(PG::ConnectionBad, error_message) unless status == PG::CONNECTION_OK
+		unless status == PG::CONNECTION_OK
+			msg = error_message
+			finish
+			raise PG::ConnectionBad, msg
+		end
 
 		# Set connection to nonblocking to handle all blocking states in ruby.
 		# That way a fiber scheduler is able to handle IO requests.

data/lib/pg/version.rb

@@ -1,4 +1,4 @@
 module PG
 	# Library version
-	VERSION = '1.3.3'
+	VERSION = '1.3.5'
 end

data/sample/async_api.rb

@@ -27,10 +27,6 @@ conn = PG::Connection.connect_start( :dbname => 'test' ) or
 abort "Connection failed: %s" % [ conn.error_message ] if
 	conn.status == PG::CONNECTION_BAD
 
-# Now grab a reference to the underlying socket so we know when the
-# connection is established
-socket = conn.socket_io
-
 # Track the progress of the connection, waiting for the socket to become readable/writable
 # before polling it
 poll_status = PG::PGRES_POLLING_WRITING
@@ -41,13 +37,13 @@ until poll_status == PG::PGRES_POLLING_OK ||
 	case poll_status
 	when PG::PGRES_POLLING_READING
 		output_progress "  waiting for socket to become readable"
-		select( [socket], nil, nil, TIMEOUT ) or
+		select( [conn.socket_io], nil, nil, TIMEOUT ) or
 			raise "Asynchronous connection timed out!"
 
 	# ...and the same for when the socket needs to write
 	when PG::PGRES_POLLING_WRITING
 		output_progress "  waiting for socket to become writable"
-		select( nil, [socket], nil, TIMEOUT ) or
+		select( nil, [conn.socket_io], nil, TIMEOUT ) or
 			raise "Asynchronous connection timed out!"
 	end
 
@@ -85,7 +81,7 @@ loop do
 	# Buffer any incoming data on the socket until a full result is ready.
 	conn.consume_input
 	while conn.is_busy
-		select( [socket], nil, nil, TIMEOUT ) or
+		select( [conn.socket_io], nil, nil, TIMEOUT ) or
 			raise "Timeout waiting for query response."
 		conn.consume_input
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.5
 platform: ruby
 authors:
 - Michael Granger
@@ -36,7 +36,7 @@ cert_chain:
   oL1mUdzB8KrZL4/WbG5YNX6UTtJbIOu9qEFbBAy4/jtIkJX+dlNoFwd4GXQW1YNO
   nA==
   -----END CERTIFICATE-----
-date: 2022-02-22 00:00:00.000000000 Z
+date: 2022-03-31 00:00:00.000000000 Z
 dependencies: []
 description: Pg is the Ruby interface to the PostgreSQL RDBMS. It works with PostgreSQL
   9.3 and later.