pg 1.3.3 → 1.5.3

data/lib/pg/connection.rb

@@ -2,8 +2,7 @@
 # frozen_string_literal: true
 
 require 'pg' unless defined?( PG )
-require 'uri'
-require 'io/wait'
+require 'io/wait' unless ::IO.public_instance_methods(false).include?(:wait_readable)
 require 'socket'
 
 # The PostgreSQL connection class. The interface for this class is based on
@@ -31,8 +30,8 @@ require 'socket'
 class PG::Connection
 
 	# The order the options are passed to the ::connect method.
-	CONNECT_ARGUMENT_ORDER = %w[host port options tty dbname user password]
-
+	CONNECT_ARGUMENT_ORDER = %w[host port options tty dbname user password].freeze
+	private_constant :CONNECT_ARGUMENT_ORDER
 
 	### Quote a single +value+ for use in a connection-parameter string.
 	def self.quote_connstr( value )
@@ -46,36 +45,9 @@ 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/
+	# Shareable program name for Ractor
+	PROGRAM_NAME = $PROGRAM_NAME.dup.freeze
+	private_constant :PROGRAM_NAME
 
 	# Parse the connection +args+ into a connection-parameter string.
 	# See PG::Connection.new for valid arguments.
@@ -87,90 +59,66 @@ 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 = {}
+			case args.first.to_s
+			when /=/, /:\/\//
+				# 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] = PROGRAM_NAME.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
 		end
 
-		if uri
-			uri += uri_match['query'] ? "&" : "?"
-			uri += URI.encode_www_form( oopts )
-			return uri
+		return connect_hash_to_string(iopts)
+	end
+
+	# Return a String representation of the object suitable for debugging.
+	def inspect
+		str = self.to_s
+		str[-1,0] = if finished?
+			" finished"
 		else
-			option_string += ' ' unless option_string.empty? && oopts.empty?
-			return option_string + connect_hash_to_string(oopts)
+			stats = []
+			stats << " status=#{ PG.constants.grep(/CONNECTION_/).find{|c| PG.const_get(c) == status} }" if status != CONNECTION_OK
+			stats << " transaction_status=#{ PG.constants.grep(/PQTRANS_/).find{|c| PG.const_get(c) == transaction_status} }" if transaction_status != PG::PQTRANS_IDLE
+			stats << " nonblocking=#{ isnonblocking }" if isnonblocking
+			stats << " pipeline_status=#{ PG.constants.grep(/PQ_PIPELINE_/).find{|c| PG.const_get(c) == pipeline_status} }" if respond_to?(:pipeline_status) && pipeline_status != PG::PQ_PIPELINE_OFF
+			stats << " client_encoding=#{ get_client_encoding }" if get_client_encoding != "UTF8"
+			stats << " type_map_for_results=#{ type_map_for_results.to_s }" unless type_map_for_results.is_a?(PG::TypeMapAllStrings)
+			stats << " type_map_for_queries=#{ type_map_for_queries.to_s }" unless type_map_for_queries.is_a?(PG::TypeMapAllStrings)
+			stats << " encoder_for_put_copy_data=#{ encoder_for_put_copy_data.to_s }" if encoder_for_put_copy_data
+			stats << " decoder_for_get_copy_data=#{ decoder_for_get_copy_data.to_s }" if decoder_for_get_copy_data
+			" host=#{host} port=#{port} user=#{user}#{stats.join}"
 		end
+		return str
 	end
 
+	BinarySignature = "PGCOPY\n\377\r\n\0".b
+	private_constant :BinarySignature
 
 	#  call-seq:
 	#     conn.copy_data( sql [, coder] ) {|sql_result| ... } -> PG::Result
@@ -218,6 +166,14 @@ class PG::Connection
 	#     conn.put_copy_data ['more', 'data', 'to', 'copy']
 	#   end
 	#
+	# Also PG::BinaryEncoder::CopyRow can be used to send data in binary format to the server.
+	# In this case copy_data generates the header and trailer data automatically:
+	#   enco = PG::BinaryEncoder::CopyRow.new
+	#   conn.copy_data "COPY my_table FROM STDIN (FORMAT binary)", enco do
+	#     conn.put_copy_data ['some', 'data', 'to', 'copy']
+	#     conn.put_copy_data ['more', 'data', 'to', 'copy']
+	#   end
+	#
 	# Example with CSV output format:
 	#   conn.copy_data "COPY my_table TO STDOUT CSV" do
 	#     while row=conn.get_copy_data
@@ -239,26 +195,58 @@ class PG::Connection
 	# This receives all rows of +my_table+ as ruby array:
 	#   ["some", "data", "to", "copy"]
 	#   ["more", "data", "to", "copy"]
+	#
+	# Also PG::BinaryDecoder::CopyRow can be used to retrieve data in binary format from the server.
+	# In this case the header and trailer data is processed by the decoder and the remaining +nil+ from get_copy_data is processed by copy_data, so that binary data can be processed equally to text data:
+	#   deco = PG::BinaryDecoder::CopyRow.new
+	#   conn.copy_data "COPY my_table TO STDOUT (FORMAT binary)", deco do
+	#     while row=conn.get_copy_data
+	#       p row
+	#     end
+	#   end
+	# This receives all rows of +my_table+ as ruby array:
+	#   ["some", "data", "to", "copy"]
+	#   ["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
 		when PGRES_COPY_IN
 			begin
+				if coder && res.binary_tuples == 1
+					# Binary file header (11 byte signature, 32 bit flags and 32 bit extension length)
+					put_copy_data(BinarySignature + ("\x00" * 8))
+				end
+
 				if coder
 					old_coder = self.encoder_for_put_copy_data
 					self.encoder_for_put_copy_data = coder
 				end
+
 				yield res
 			rescue Exception => err
 				errmsg = "%s while copy data: %s" % [ err.class.name, err.message ]
-				put_copy_end( errmsg )
-				get_result
-				raise
+				begin
+					put_copy_end( errmsg )
+				rescue PG::Error
+					# Ignore error in cleanup to avoid losing original exception
+				end
+				discard_results
+				raise err
 			else
-				put_copy_end
+				begin
+					self.encoder_for_put_copy_data = old_coder if coder
+
+					if coder && res.binary_tuples == 1
+						put_copy_data("\xFF\xFF") # Binary file trailer 16 bit "-1"
+					end
+
+					put_copy_end
+				rescue PG::Error => err
+					raise PG::LostCopyState.new("#{err} (probably by executing another SQL query while running a COPY command)", connection: self)
+				end
 				get_last_result
 			ensure
 				self.encoder_for_put_copy_data = old_coder if coder
@@ -271,21 +259,26 @@ class PG::Connection
 					self.decoder_for_get_copy_data = coder
 				end
 				yield res
-			rescue Exception => err
+			rescue Exception
 				cancel
-				while get_copy_data
-				end
-				while get_result
-				end
+				discard_results
 				raise
 			else
-				res = get_last_result
-				if !res || res.result_status != PGRES_COMMAND_OK
-					while get_copy_data
-					end
-					while get_result
+				if coder && res.binary_tuples == 1
+					# There are two end markers in binary mode: file trailer and the final nil.
+					# The file trailer is expected to be processed by BinaryDecoder::CopyRow and already returns nil, so that the remaining NULL from PQgetCopyData is retrieved here:
+					if get_copy_data
+						discard_results
+						raise PG::NotAllCopyDataRetrieved.new("Not all binary COPY data retrieved", connection: self)
 					end
-					raise PG::NotAllCopyDataRetrieved, "Not all COPY data retrieved"
+				end
+				res = get_last_result
+				if !res
+					discard_results
+					raise PG::LostCopyState.new("Lost COPY state (probably by executing another SQL query while running a COPY command)", connection: self)
+				elsif res.result_status != PGRES_COMMAND_OK
+					discard_results
+					raise PG::NotAllCopyDataRetrieved.new("Not all COPY data retrieved", connection: self)
 				end
 				res
 			ensure
@@ -310,16 +303,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
@@ -372,6 +366,23 @@ class PG::Connection
 		end
 	end
 
+	# Read all pending socket input to internal memory and raise an exception in case of errors.
+	#
+	# This verifies that the connection socket is in a usable state and not aborted in any way.
+	# No communication is done with the server.
+	# Only pending data is read from the socket - the method doesn't wait for any outstanding server answers.
+	#
+	# Raises a kind of PG::Error if there was an error reading the data or if the socket is in a failure state.
+	#
+	# The method doesn't verify that the server is still responding.
+	# To verify that the communication to the server works, it is recommended to use something like <tt>conn.exec('')</tt> instead.
+	def check_socket
+		while socket_io.wait_readable(0)
+			consume_input
+		end
+		nil
+	end
+
 	# call-seq:
 	#    conn.get_result() -> PG::Result
 	#    conn.get_result() {|pg_result| block }
@@ -482,10 +493,20 @@ class PG::Connection
 	# See also #copy_data.
 	#
 	def put_copy_data(buffer, encoder=nil)
-		until sync_put_copy_data(buffer, encoder)
-			flush
+		# sync_put_copy_data does a non-blocking attept to flush data.
+		until res=sync_put_copy_data(buffer, encoder)
+			# It didn't flush immediately and allocation of more buffering memory failed.
+			# Wait for all data sent by doing a blocking flush.
+			res = flush
 		end
-		flush
+
+		# And do a blocking flush every 100 calls.
+		# This is to avoid memory bloat, when sending the data is slower than calls to put_copy_data happen.
+		if (@calls_to_put_copy_data += 1) > 100
+			@calls_to_put_copy_data = 0
+			res = flush
+		end
+		res
 	end
 	alias async_put_copy_data put_copy_data
 
@@ -505,6 +526,7 @@ class PG::Connection
 		until sync_put_copy_end(*args)
 			flush
 		end
+		@calls_to_put_copy_data = 0
 		flush
 	end
 	alias async_put_copy_end put_copy_end
@@ -545,6 +567,7 @@ class PG::Connection
 	def reset
 		reset_start
 		async_connect_or_reset(:reset_poll)
+		self
 	end
 	alias async_reset reset
 
@@ -612,37 +635,72 @@ 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
+
+		if (timeo = conninfo_hash[:connect_timeout].to_i) && timeo > 0
+			# Lowest timeout is 2 seconds - like in libpq
+			timeo = [timeo, 2].max
+			host_count = conninfo_hash[:host].to_s.count(",") + 1
+			stop_time = timeo * host_count + 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.wait_readable
+			# Set single timeout to parameter "connect_timeout" but
+			# don't exceed total connection time of number-of-hosts * connect_timeout.
+			timeout = [timeo, stop_time - Process.clock_gettime(Process::CLOCK_MONOTONIC)].min if stop_time
+			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.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 )
 		end
 
-		raise(PG::ConnectionBad, error_message) unless status == PG::CONNECTION_OK
+		unless status == PG::CONNECTION_OK
+			msg = error_message
+			finish
+			raise PG::ConnectionBad.new(msg, connection: self)
+		end
 
 		# Set connection to nonblocking to handle all blocking states in ruby.
 		# That way a fiber scheduler is able to handle IO requests.
 		sync_setnonblocking(true)
 		self.flush_data = true
 		set_default_encoding
-
-		self
 	end
 
 	class << self
@@ -697,13 +755,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
@@ -711,12 +773,74 @@ 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)
+
+			if iopts[:hostaddr]
+				# hostaddr is provided -> no need to resolve hostnames
+
+			elsif iopts[:host] && !iopts[:host].empty? && PG.library_version >= 100000
+				# Resolve DNS in Ruby to avoid blocking state while connecting.
+				# Multiple comma-separated values are generated, if the hostname resolves to both IPv4 and IPv6 addresses.
+				# This requires PostgreSQL-10+, so no DNS resolving is done on earlier versions.
+				ihosts = iopts[:host].split(",", -1)
+				iports = iopts[:port].split(",", -1)
+				iports = [nil] if iports.size == 0
+				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
+
+				dests = ihosts.each_with_index.flat_map do |mhost, idx|
+					unless host_is_named_pipe?(mhost)
+						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.
+							hostaddrs = Thread.new{ Addrinfo.getaddrinfo(mhost, nil, nil, :STREAM).map(&:ip_address) rescue [''] }.value
+						else
+							hostaddrs = Addrinfo.getaddrinfo(mhost, nil, nil, :STREAM).map(&:ip_address) rescue ['']
+						end
+					else
+						# No hostname to resolve (UnixSocket)
+						hostaddrs = [nil]
+					end
+					hostaddrs.map { |hostaddr| [hostaddr, mhost, iports[idx]] }
+				end
+				iopts.merge!(
+					hostaddr: dests.map{|d| d[0] }.join(","),
+					host: dests.map{|d| d[1] }.join(","),
+					port: dests.map{|d| d[2] }.join(","))
+			else
+				# No host given
+			end
+			conn = self.connect_start(iopts) 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)
+			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
 		#    PG::Connection.ping(host, port, options, tty, dbname, login, password) ->  Integer
 		#
-		# Check server status.
+		# PQpingParams reports the status of the server.
+		#
+		# It accepts connection parameters identical to those of PQ::Connection.new .
+		# It is not necessary to supply correct user name, password, or database name values to obtain the server status; however, if incorrect values are provided, the server will log a failed connection attempt.
 		#
 		# See PG::Connection.new for a description of the parameters.
 		#
@@ -729,6 +853,8 @@ class PG::Connection
 		#   could not establish connection
 		# [+PQPING_NO_ATTEMPT+]
 		#   connection not attempted (bad params)
+		#
+		# See also check_socket for a way to check the connection without doing any server communication.
 		def ping(*args)
 			if Fiber.respond_to?(:scheduler) && Fiber.scheduler
 				# Run PQping in a second thread to avoid blocking of the scheduler.
@@ -740,23 +866,25 @@ class PG::Connection
 		end
 		alias async_ping ping
 
-		REDIRECT_CLASS_METHODS = {
+		REDIRECT_CLASS_METHODS = PG.make_shareable({
 			:new => [:async_connect, :sync_connect],
 			:connect => [:async_connect, :sync_connect],
 			:open => [:async_connect, :sync_connect],
 			:setdb => [:async_connect, :sync_connect],
 			:setdblogin => [:async_connect, :sync_connect],
 			:ping => [:async_ping, :sync_ping],
-		}
+		})
+		private_constant :REDIRECT_CLASS_METHODS
 
 		# These methods are affected by PQsetnonblocking
-		REDIRECT_SEND_METHODS = {
+		REDIRECT_SEND_METHODS = PG.make_shareable({
 			:isnonblocking => [:async_isnonblocking, :sync_isnonblocking],
 			:nonblocking? => [:async_isnonblocking, :sync_isnonblocking],
 			:put_copy_data => [:async_put_copy_data, :sync_put_copy_data],
 			:put_copy_end => [:async_put_copy_end, :sync_put_copy_end],
 			:flush => [:async_flush, :sync_flush],
-		}
+		})
+		private_constant :REDIRECT_SEND_METHODS
 		REDIRECT_METHODS = {
 			:exec => [:async_exec, :sync_exec],
 			:query => [:async_exec, :sync_exec],
@@ -774,12 +902,14 @@ class PG::Connection
 			:client_encoding= => [:async_set_client_encoding, :sync_set_client_encoding],
 			:cancel => [:async_cancel, :sync_cancel],
 		}
+		private_constant :REDIRECT_METHODS
 
 		if PG::Connection.instance_methods.include? :async_encrypt_password
 			REDIRECT_METHODS.merge!({
 				:encrypt_password => [:async_encrypt_password, :sync_encrypt_password],
 			})
 		end
+		PG.make_shareable(REDIRECT_METHODS)
 
 		def async_send_api=(enable)
 			REDIRECT_SEND_METHODS.each do |ali, (async, sync)|

data/lib/pg/exceptions.rb

@@ -6,7 +6,20 @@ 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
+
+	class NotAllCopyDataRetrieved < PG::Error
+	end
+	class LostCopyState < PG::Error
+	end
+	class NotInBlockingMode < PG::Error
+	end
 
 end # module PG
 

data/lib/pg/text_decoder/date.rb

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'date'
+
+module PG
+	module TextDecoder
+		class Date < SimpleDecoder
+			def decode(string, tuple=nil, field=nil)
+				if string =~ /\A(\d{4})-(\d\d)-(\d\d)\z/
+					::Date.new $1.to_i, $2.to_i, $3.to_i
+				else
+					string
+				end
+			end
+		end
+	end
+end # module PG

data/lib/pg/text_decoder/inet.rb

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+module PG
+	module TextDecoder
+		# Init C part of the decoder
+		init_inet
+	end
+end # module PG