pg 1.3.4-x86-mingw32 → 1.4.1-x86-mingw32

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

@@ -1457,6 +1457,7 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int, void*), void* d
 
 		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");
@@ -1475,10 +1476,10 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int, void*), void* d
 
 		pgresult = gvl_PQgetResult(pgconn);
 		if( pgresult == NULL )
-			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another result retrieval");
+			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another query");
 
 		if( nfields != PQnfields(pgresult) )
-			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields must not change in single row mode");
+			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields changed in single row mode from %d to %d - this is a sign for intersection with another query", nfields, PQnfields(pgresult));
 
 		this->pgresult = pgresult;
 	}

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

@@ -46,37 +46,6 @@ class PG::Connection
 		hash.map { |k,v| "#{k}=#{quote_connstr(v)}" }.join( ' ' )
 	end
 
-	# Decode a connection string to Hash options
-	#
-	# Value are properly unquoted and unescaped.
-	def self.connect_string_to_hash( str )
-		options = {}
-		key = nil
-		value = String.new
-		str.scan(/\G\s*(?>([^\s\\\']+)\s*=\s*|([^\s\\\']+)|'((?:[^\'\\]|\\.)*)'|(\\.?)|(\S))(\s|\z)?/m) do
-					|k, word, sq, esc, garbage, sep|
-			raise ArgumentError, "unterminated quoted string in connection info string: #{str.inspect}" if garbage
-			if k
-				key = k
-			else
-				value << (word || (sq || esc).gsub(/\\(.)/, '\\1'))
-			end
-			if sep
-				raise ArgumentError, "missing = after #{value.inspect}" unless key
-				options[key.to_sym] = value
-				key = nil
-				value = String.new
-			end
-		end
-		options
-	end
-
-	# URI defined in RFC3986
-	# This regexp is modified to allow host to specify multiple comma separated components captured as <hostports> and to disallow comma in hostnames.
-	# Taken from: https://github.com/ruby/ruby/blob/be04006c7d2f9aeb7e9d8d09d945b3a9c7850202/lib/uri/rfc3986_parser.rb#L6
-	HOST_AND_PORT = /(?<hostport>(?<host>(?<IP-literal>\[(?:(?<IPv6address>(?:\h{1,4}:){6}(?<ls32>\h{1,4}:\h{1,4}|(?<IPv4address>(?<dec-octet>[1-9]\d|1\d{2}|2[0-4]\d|25[0-5]|\d)\.\g<dec-octet>\.\g<dec-octet>\.\g<dec-octet>))|::(?:\h{1,4}:){5}\g<ls32>|\h{1,4}?::(?:\h{1,4}:){4}\g<ls32>|(?:(?:\h{1,4}:)?\h{1,4})?::(?:\h{1,4}:){3}\g<ls32>|(?:(?:\h{1,4}:){,2}\h{1,4})?::(?:\h{1,4}:){2}\g<ls32>|(?:(?:\h{1,4}:){,3}\h{1,4})?::\h{1,4}:\g<ls32>|(?:(?:\h{1,4}:){,4}\h{1,4})?::\g<ls32>|(?:(?:\h{1,4}:){,5}\h{1,4})?::\h{1,4}|(?:(?:\h{1,4}:){,6}\h{1,4})?::)|(?<IPvFuture>v\h+\.[!$&-.0-;=A-Z_a-z~]+))\])|\g<IPv4address>|(?<reg-name>(?:%\h\h|[-\.!$&-+0-9;=A-Z_a-z~])+))?(?::(?<port>\d*))?)/
-	POSTGRESQL_URI = /\A(?<URI>(?<scheme>[A-Za-z][+\-.0-9A-Za-z]*):(?<hier-part>\/\/(?<authority>(?:(?<userinfo>(?:%\h\h|[!$&-.0-;=A-Z_a-z~])*)@)?(?<hostports>#{HOST_AND_PORT}(?:,\g<hostport>)*))(?<path-abempty>(?:\/(?<segment>(?:%\h\h|[!$&-.0-;=@-Z_a-z~])*))*)|(?<path-absolute>\/(?:(?<segment-nz>(?:%\h\h|[!$&-.0-;=@-Z_a-z~])+)(?:\/\g<segment>)*)?)|(?<path-rootless>\g<segment-nz>(?:\/\g<segment>)*)|(?<path-empty>))(?:\?(?<query>[^#]*))?(?:\#(?<fragment>(?:%\h\h|[!$&-.0-;=@-Z_a-z~\/?])*))?)\z/
-
 	# Parse the connection +args+ into a connection-parameter string.
 	# See PG::Connection.new for valid arguments.
 	#
@@ -87,91 +56,43 @@ class PG::Connection
 	# * URI object
 	# * positional arguments
 	#
-	# The method adds the option "hostaddr" and "fallback_application_name" if they aren't already set.
-	# The URI and the options string is passed through and "hostaddr" as well as "fallback_application_name"
-	# are added to the end.
-	def self::parse_connect_args( *args )
+	# The method adds the option "fallback_application_name" if it isn't already set.
+	# It returns a connection string with "key=value" pairs.
+	def self.parse_connect_args( *args )
 		hash_arg = args.last.is_a?( Hash ) ? args.pop.transform_keys(&:to_sym) : {}
-		option_string = ""
 		iopts = {}
 
 		if args.length == 1
 			case args.first
-			when URI, POSTGRESQL_URI
-				uri = args.first.to_s
-				uri_match = POSTGRESQL_URI.match(uri)
-				if uri_match['query']
-					iopts = URI.decode_www_form(uri_match['query']).to_h.transform_keys(&:to_sym)
-				end
-				# extract "host1,host2" from "host1:5432,host2:5432"
-				iopts[:host] = uri_match['hostports'].split(',', -1).map do |hostport|
-					hostmatch = /\A#{HOST_AND_PORT}\z/.match(hostport)
-					hostmatch['IPv6address'] || hostmatch['IPv4address'] || hostmatch['reg-name']&.gsub(/%(\h\h)/){ $1.hex.chr }
-				end.join(',')
-				oopts = {}
-			when /=/
-				# Option string style
-				option_string = args.first.to_s
-				iopts = connect_string_to_hash(option_string)
-				oopts = {}
+			when URI, /=/, /:\/\//
+				# Option or URL string style
+				conn_string = args.first.to_s
+				iopts = PG::Connection.conninfo_parse(conn_string).each_with_object({}){|h, o| o[h[:keyword].to_sym] = h[:val] if h[:val] }
 			else
 				# Positional parameters (only host given)
 				iopts[CONNECT_ARGUMENT_ORDER.first.to_sym] = args.first
-				oopts = iopts.dup
 			end
 		else
-			# Positional parameters
+			# Positional parameters with host and more
 			max = CONNECT_ARGUMENT_ORDER.length
 			raise ArgumentError,
-				"Extra positional parameter %d: %p" % [ max + 1, args[max] ] if args.length > max
+					"Extra positional parameter %d: %p" % [ max + 1, args[max] ] if args.length > max
 
 			CONNECT_ARGUMENT_ORDER.zip( args ) do |(k,v)|
 				iopts[ k.to_sym ] = v if v
 			end
 			iopts.delete(:tty) # ignore obsolete tty parameter
-			oopts = iopts.dup
 		end
 
 		iopts.merge!( hash_arg )
-		oopts.merge!( hash_arg )
-
-		# Resolve DNS in Ruby to avoid blocking state while connecting, when it ...
-		if (host=iopts[:host]) && !iopts[:hostaddr]
-			hostaddrs = host.split(",", -1).map do |mhost|
-				if !mhost.empty? && !mhost.start_with?("/") &&  # isn't UnixSocket
-						# isn't a path on Windows
-						(RUBY_PLATFORM !~ /mingw|mswin/ || mhost !~ /\A\w:[\/\\]/)
-
-					if Fiber.respond_to?(:scheduler) &&
-							Fiber.scheduler &&
-							RUBY_VERSION < '3.1.'
-
-						# Use a second thread to avoid blocking of the scheduler.
-						# `IPSocket.getaddress` isn't fiber aware before ruby-3.1.
-						Thread.new{ IPSocket.getaddress(mhost) rescue '' }.value
-					else
-						IPSocket.getaddress(mhost) rescue ''
-					end
-				end
-			end
-			oopts[:hostaddr] = hostaddrs.join(",") if hostaddrs.any?
-		end
 
 		if !iopts[:fallback_application_name]
-			oopts[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
+			iopts[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
 		end
 
-		if uri
-			uri += uri_match['query'] ? "&" : "?"
-			uri += URI.encode_www_form( oopts )
-			return uri
-		else
-			option_string += ' ' unless option_string.empty? && oopts.empty?
-			return option_string + connect_hash_to_string(oopts)
-		end
+		return connect_hash_to_string(iopts)
 	end
 
-
 	#  call-seq:
 	#     conn.copy_data( sql [, coder] ) {|sql_result| ... } -> PG::Result
 	#
@@ -241,7 +162,7 @@ class PG::Connection
 	#   ["more", "data", "to", "copy"]
 
 	def copy_data( sql, coder=nil )
-		raise PG::NotInBlockingMode, "copy_data can not be used in nonblocking mode" if nonblocking?
+		raise PG::NotInBlockingMode.new("copy_data can not be used in nonblocking mode", connection: self) if nonblocking?
 		res = exec( sql )
 
 		case res.result_status
@@ -273,11 +194,15 @@ class PG::Connection
 				yield res
 			rescue Exception => err
 				cancel
-				while get_copy_data
+				begin
+					while get_copy_data
+					end
+				rescue PG::Error
+					# Ignore error in cleanup to avoid losing original exception
 				end
 				while get_result
 				end
-				raise
+				raise err
 			else
 				res = get_last_result
 				if !res || res.result_status != PGRES_COMMAND_OK
@@ -285,7 +210,7 @@ class PG::Connection
 					end
 					while get_result
 					end
-					raise PG::NotAllCopyDataRetrieved, "Not all COPY data retrieved"
+					raise PG::NotAllCopyDataRetrieved.new("Not all COPY data retrieved", connection: self)
 				end
 				res
 			ensure
@@ -310,16 +235,17 @@ class PG::Connection
 	# and a +COMMIT+ at the end of the block, or
 	# +ROLLBACK+ if any exception occurs.
 	def transaction
+		rollback = false
 		exec "BEGIN"
-		res = yield(self)
+		yield(self)
 	rescue Exception
+		rollback = true
 		cancel if transaction_status == PG::PQTRANS_ACTIVE
 		block
 		exec "ROLLBACK"
 		raise
-	else
-		exec "COMMIT"
-		res
+	ensure
+		exec "COMMIT" unless rollback
 	end
 
 	### Returns an array of Hashes with connection defaults. See ::conndefaults
@@ -482,10 +408,10 @@ class PG::Connection
 	# See also #copy_data.
 	#
 	def put_copy_data(buffer, encoder=nil)
-		until sync_put_copy_data(buffer, encoder)
-			flush
+		until res=sync_put_copy_data(buffer, encoder)
+			res = flush
 		end
-		flush
+		res
 	end
 	alias async_put_copy_data put_copy_data
 
@@ -545,6 +471,7 @@ class PG::Connection
 	def reset
 		reset_start
 		async_connect_or_reset(:reset_poll)
+		self
 	end
 	alias async_reset reset
 
@@ -613,28 +540,62 @@ class PG::Connection
 
 	private def async_connect_or_reset(poll_meth)
 		# Track the progress of the connection, waiting for the socket to become readable/writable before polling it
+
+		if (timeo = conninfo_hash[:connect_timeout].to_i) && timeo > 0
+			# Lowest timeout is 2 seconds - like in libpq
+			timeo = [timeo, 2].max
+			stop_time = timeo + Process.clock_gettime(Process::CLOCK_MONOTONIC)
+		end
+
 		poll_status = PG::PGRES_POLLING_WRITING
 		until poll_status == PG::PGRES_POLLING_OK ||
 				poll_status == PG::PGRES_POLLING_FAILED
 
-			# If the socket needs to read, wait 'til it becomes readable to poll again
-			case poll_status
-			when PG::PGRES_POLLING_READING
-				socket_io.wait_readable
+			timeout = stop_time&.-(Process.clock_gettime(Process::CLOCK_MONOTONIC))
+			event = if !timeout || timeout >= 0
+				# If the socket needs to read, wait 'til it becomes readable to poll again
+				case poll_status
+				when PG::PGRES_POLLING_READING
+					if defined?(IO::READABLE) # ruby-3.0+
+						socket_io.wait(IO::READABLE | IO::PRIORITY, timeout)
+					else
+						IO.select([socket_io], nil, [socket_io], timeout)
+					end
 
-			# ...and the same for when the socket needs to write
-			when PG::PGRES_POLLING_WRITING
-				socket_io.wait_writable
+				# ...and the same for when the socket needs to write
+				when PG::PGRES_POLLING_WRITING
+					if defined?(IO::WRITABLE) # ruby-3.0+
+						# Use wait instead of wait_readable, since connection errors are delivered as
+						# exceptional/priority events on Windows.
+						socket_io.wait(IO::WRITABLE | IO::PRIORITY, timeout)
+					else
+						# io#wait on ruby-2.x doesn't wait for priority, so fallback to IO.select
+						IO.select(nil, [socket_io], [socket_io], timeout)
+					end
+				end
+			end
+			# connection to server at "localhost" (127.0.0.1), port 5433 failed: timeout expired (PG::ConnectionBad)
+			# connection to server on socket "/var/run/postgresql/.s.PGSQL.5433" failed: No such file or directory
+			unless event
+				if self.class.send(:host_is_named_pipe?, host)
+					connhost = "on socket \"#{host}\""
+				elsif respond_to?(:hostaddr)
+					connhost = "at \"#{host}\" (#{hostaddr}), port #{port}"
+				else
+					connhost = "at \"#{host}\", port #{port}"
+				end
+				raise PG::ConnectionBad.new("connection to server #{connhost} failed: timeout expired", connection: self)
 			end
 
 			# Check to see if it's finished or failed yet
 			poll_status = send( poll_meth )
+			@last_status = status unless [PG::CONNECTION_BAD, PG::CONNECTION_OK].include?(status)
 		end
 
 		unless status == PG::CONNECTION_OK
 			msg = error_message
 			finish
-			raise PG::ConnectionBad, msg
+			raise PG::ConnectionBad.new(msg, connection: self)
 		end
 
 		# Set connection to nonblocking to handle all blocking states in ruby.
@@ -642,8 +603,6 @@ class PG::Connection
 		sync_setnonblocking(true)
 		self.flush_data = true
 		set_default_encoding
-
-		self
 	end
 
 	class << self
@@ -698,13 +657,17 @@ class PG::Connection
 		# connection will have its +client_encoding+ set accordingly.
 		#
 		# Raises a PG::Error if the connection fails.
-		def new(*args, **kwargs)
-			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
-
-			conn.send(:async_connect_or_reset, :connect_poll)
+		def new(*args)
+			conn = connect_to_hosts(*args)
+
+			if block_given?
+				begin
+					return yield conn
+				ensure
+					conn.finish
+				end
+			end
+			conn
 		end
 		alias async_connect new
 		alias connect new
@@ -712,6 +675,99 @@ class PG::Connection
 		alias setdb new
 		alias setdblogin new
 
+		private def connect_to_hosts(*args)
+			option_string = parse_connect_args(*args)
+			iopts = PG::Connection.conninfo_parse(option_string).each_with_object({}){|h, o| o[h[:keyword].to_sym] = h[:val] if h[:val] }
+			iopts = PG::Connection.conndefaults.each_with_object({}){|h, o| o[h[:keyword].to_sym] = h[:val] if h[:val] }.merge(iopts)
+
+			errors = []
+			if iopts[:hostaddr]
+				# hostaddr is provided -> no need to resolve hostnames
+				ihostaddrs = iopts[:hostaddr].split(",", -1)
+
+				ihosts = iopts[:host].split(",", -1) if iopts[:host]
+				raise PG::ConnectionBad, "could not match #{ihosts.size} host names to #{ihostaddrs.size} hostaddr values" if ihosts && ihosts.size != ihostaddrs.size
+
+				iports = iopts[:port].split(",", -1)
+				iports = iports * ihostaddrs.size if iports.size == 1
+				raise PG::ConnectionBad, "could not match #{iports.size} port numbers to #{ihostaddrs.size} hosts" if iports.size != ihostaddrs.size
+
+				# Try to connect to each hostaddr with separate timeout
+				ihostaddrs.each_with_index do |ihostaddr, idx|
+					oopts = iopts.merge(hostaddr: ihostaddr, port: iports[idx])
+					oopts[:host] = ihosts[idx] if ihosts
+					c = connect_internal(oopts, errors)
+					return c if c
+				end
+			elsif iopts[:host]
+				# Resolve DNS in Ruby to avoid blocking state while connecting, when it ...
+				ihosts = iopts[:host].split(",", -1)
+
+				iports = iopts[:port].split(",", -1)
+				iports = iports * ihosts.size if iports.size == 1
+				raise PG::ConnectionBad, "could not match #{iports.size} port numbers to #{ihosts.size} hosts" if iports.size != ihosts.size
+
+				ihosts.each_with_index do |mhost, idx|
+					unless host_is_named_pipe?(mhost)
+						addrs = if Fiber.respond_to?(:scheduler) &&
+									Fiber.scheduler &&
+									RUBY_VERSION < '3.1.'
+
+							# Use a second thread to avoid blocking of the scheduler.
+							# `TCPSocket.gethostbyname` isn't fiber aware before ruby-3.1.
+							Thread.new{ Addrinfo.getaddrinfo(mhost, nil, nil, :STREAM).map(&:ip_address) rescue [''] }.value
+						else
+							Addrinfo.getaddrinfo(mhost, nil, nil, :STREAM).map(&:ip_address) rescue ['']
+						end
+
+						# Try to connect to each host with separate timeout
+						addrs.each do |addr|
+							oopts = iopts.merge(hostaddr: addr, host: mhost, port: iports[idx])
+							c = connect_internal(oopts, errors)
+							return c if c
+						end
+					else
+						# No hostname to resolve (UnixSocket)
+						oopts = iopts.merge(host: mhost, port: iports[idx])
+						c = connect_internal(oopts, errors)
+						return c if c
+					end
+				end
+			else
+				# No host given
+				return connect_internal(iopts)
+			end
+			raise PG::ConnectionBad, errors.join("\n")
+		end
+
+		private def connect_internal(opts, errors=nil)
+			begin
+				conn = self.connect_start(opts) or
+											raise(PG::Error, "Unable to create a new connection")
+
+				raise PG::ConnectionBad.new(conn.error_message, connection: self) if conn.status == PG::CONNECTION_BAD
+
+				conn.send(:async_connect_or_reset, :connect_poll)
+			rescue PG::ConnectionBad => err
+				if errors && !(conn && [PG::CONNECTION_AWAITING_RESPONSE].include?(conn.instance_variable_get(:@last_status)))
+					# Seems to be no authentication error -> try next host
+					errors << err
+					return nil
+				else
+					# Probably an authentication error
+					raise
+				end
+			end
+			conn
+		end
+
+		private def host_is_named_pipe?(host_string)
+			host_string.empty? || host_string.start_with?("/") ||  # it's UnixSocket?
+							host_string.start_with?("@") ||  # it's UnixSocket in the abstract namespace?
+							# it's a path on Windows?
+							(RUBY_PLATFORM =~ /mingw|mswin/ && host_string =~ /\A([\/\\]|\w:[\/\\])/)
+		end
+
 		# call-seq:
 		#    PG::Connection.ping(connection_hash)       -> Integer
 		#    PG::Connection.ping(connection_string)     -> Integer

data/lib/pg/exceptions.rb

@@ -6,7 +6,13 @@ require 'pg' unless defined?( PG )
 
 module PG
 
-	class Error < StandardError; end
+	class Error < StandardError
+		def initialize(msg=nil, connection: nil, result: nil)
+			@connection = connection
+			@result = result
+			super(msg)
+		end
+	end
 
 end # module PG
 

data/lib/pg/version.rb

@@ -1,4 +1,4 @@
 module PG
 	# Library version
-	VERSION = '1.3.4'
+	VERSION = '1.4.1'
 end

data/lib/pg.rb

@@ -59,14 +59,14 @@ module PG
 	# Get the PG library version.
 	#
 	# +include_buildnum+ is no longer used and any value passed will be ignored.
-	def self::version_string( include_buildnum=nil )
-		return "%s %s" % [ self.name, VERSION ]
+	def self.version_string( include_buildnum=nil )
+		"%s %s" % [ self.name, VERSION ]
 	end
 
 
 	### Convenience alias for PG::Connection.new.
-	def self::connect( *args, **kwargs )
-		return PG::Connection.new( *args, **kwargs )
+	def self.connect( *args, &block )
+		Connection.new( *args, &block )
 	end
 
 

metadata

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