pg 1.6.0.rc1-x86-mingw32 → 1.6.0-x86-mingw32

data/lib/pg/cancel_connection.rb

@@ -7,8 +7,24 @@ if defined?(PG::CancelConnection)
 	class PG::CancelConnection
 		include PG::Connection::Pollable
 
-		# The timeout used by #cancel and async_cancel to establish the cancel connection.
-		attr_accessor :async_connect_timeout
+		alias c_initialize initialize
+
+		def initialize(conn)
+			c_initialize(conn)
+
+			# A cancel connection is always to one destination server only.
+			# Prepare conninfo_hash with just enough information to allow a shared polling_loop.
+			@host = conn.host
+			@hostaddr = conn.hostaddr
+			@port = conn.port
+
+			@conninfo_hash = {
+				host: @host,
+				hostaddr: @hostaddr,
+				port: @port.to_s,
+				connect_timeout: conn.conninfo_hash[:connect_timeout],
+			}
+		end
 
 		# call-seq:
 		#    conn.cancel
@@ -23,8 +39,15 @@ if defined?(PG::CancelConnection)
 		#
 		def cancel
 			start
-			polling_loop(:poll, async_connect_timeout)
+			polling_loop(:poll)
 		end
 		alias async_cancel cancel
+
+		# These private methods are there to allow a shared polling_loop.
+		private
+		attr_reader :host
+		attr_reader :hostaddr
+		attr_reader :port
+		attr_reader :conninfo_hash
 	end
 end

data/lib/pg/coder.rb

@@ -76,12 +76,13 @@ module PG
 				elements_type: elements_type,
 				needs_quotation: needs_quotation?,
 				delimiter: delimiter,
+				dimensions: dimensions,
 			}
 		end
 
 		def inspect
 			str = super
-			str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation"
+			str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation#{dimensions && " #{dimensions} dimensions"}"
 			str
 		end
 	end

data/lib/pg/connection.rb

@@ -625,7 +625,6 @@ class PG::Connection
 		# On older client library a pure ruby implementation is used.
 		def cancel
 			cancon = PG::CancelConnection.new(self)
-			cancon.async_connect_timeout = conninfo_hash[:connect_timeout]
 			cancon.async_cancel
 		rescue PG::Error => err
 			err.to_s
@@ -674,20 +673,35 @@ class PG::Connection
 	alias async_cancel cancel
 
 	module Pollable
-		# Track the progress of the connection, waiting for the socket to become readable/writable before polling it
-		private def polling_loop(poll_meth, connect_timeout)
+		# Track the progress of the connection, waiting for the socket to become readable/writable before polling it.
+		#
+		# Connecting to multiple hosts is done like so:
+		# - All hosts are passed to PG::Connection.connect_start
+		# - As soon as the host is tried to connect the related host is removed from the hosts list
+		# - When the polling status changes to `PG::PGRES_POLLING_OK` the connection is returned and ready to use.
+		# - When the polling status changes to `PG::PGRES_POLLING_FAILED` connecting is aborted and a PG::ConnectionBad is raised with details to all connection attepts.
+		# - When a timeout occurs, connecting is restarted with the remaining hosts.
+		#
+		# The downside is that this connects only once to hosts which are listed twice when they timeout.
+		private def polling_loop(poll_meth)
+			connect_timeout = conninfo_hash[:connect_timeout]
 			if (timeo = connect_timeout.to_i) && timeo > 0
-				host_count = conninfo_hash[:host].to_s.count(",") + 1
+				host_count = (conninfo_hash[:hostaddr].to_s.empty? ? conninfo_hash[:host] : conninfo_hash[:hostaddr]).to_s.count(",") + 1
 				stop_time = timeo * host_count + Process.clock_gettime(Process::CLOCK_MONOTONIC)
 			end
-
+			iopts = conninfo_hash.compact
+			connection_errors = []
 			poll_status = PG::PGRES_POLLING_WRITING
+
 			until poll_status == PG::PGRES_POLLING_OK ||
 					poll_status == PG::PGRES_POLLING_FAILED
 
 				# 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
+
+				hostcnt = remove_current_host(iopts)
+
 				event = if !timeout || timeout >= 0
 					# If the socket needs to read, wait 'til it becomes readable to poll again
 					case poll_status
@@ -710,17 +724,21 @@ class PG::Connection
 						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}"
+					connection_errors << (error_message + "timeout expired")
+					if hostcnt > 0
+						reset_start2(self.class.parse_connect_args(iopts))
+						# Restart polling with waiting for writable.
+						# Otherwise "not connected" error is raised on Windows.
+						poll_status = PG::PGRES_POLLING_WRITING
+						next
 					else
-						connhost = "at \"#{host}\", port #{port}"
+						finish
+						raise PG::ConnectionBad.new(connection_errors.join("\n").b, connection: self)
 					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
@@ -730,16 +748,51 @@ class PG::Connection
 			unless status == PG::CONNECTION_OK
 				msg = error_message
 				finish
-				raise PG::ConnectionBad.new(msg, connection: self)
+				raise PG::ConnectionBad.new(connection_errors.map{|e| e + "\n" }.join.b + msg, connection: self)
 			end
 		end
+
+		# Remove the host to which the connection is currently established from the option hash.
+		# Affected options are:
+		# - :host
+		# - :hostaddr
+		# - :port
+		#
+		# Return the number of remaining hosts.
+		private def remove_current_host(iopts)
+			ihosts = iopts[:host]&.split(",", -1)
+			ihostaddrs = iopts[:hostaddr]&.split(",", -1)
+			iports = iopts[:port]&.split(",", -1)
+			iports = iports * (ihosts || ihostaddrs || [1]).size if iports&.size == 1
+
+			idx = (ihosts || ihostaddrs || iports).index.with_index do |_, i|
+				(ihosts ? ihosts[i] == host : true) &&
+				(ihostaddrs && respond_to?(:hostaddr, true) ? ihostaddrs[i] == hostaddr : true) &&
+				(iports ? iports[i].to_i == port : true)
+			end
+
+			if idx
+				ihosts&.delete_at(idx)
+				ihostaddrs&.delete_at(idx)
+				iports&.delete_at(idx)
+
+				iopts.merge!(
+					host: ihosts.join(",")) if ihosts
+				iopts.merge!(
+					hostaddr: ihostaddrs.join(",")) if ihostaddrs
+				iopts.merge!(
+					port: iports.join(",")) if iports
+			end
+
+			(ihosts || ihostaddrs || iports).size
+		end
 	end
 
 	include Pollable
 
 	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
-		polling_loop(poll_meth, conninfo_hash[:connect_timeout])
+		polling_loop(poll_meth)
 
 		# Set connection to nonblocking to handle all blocking states in ruby.
 		# That way a fiber scheduler is able to handle IO requests.
@@ -755,7 +808,7 @@ class PG::Connection
 		#    PG::Connection.new(connection_string) -> conn
 		#    PG::Connection.new(host, port, options, tty, dbname, user, password) ->  conn
 		#
-		# Create a connection to the specified server.
+		# === Create a connection to the specified server.
 		#
 		# +connection_hash+ must be a ruby Hash with connection parameters.
 		# See the {list of valid parameters}[https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PARAMKEYWORDS] in the PostgreSQL documentation.
@@ -779,7 +832,13 @@ class PG::Connection
 		# [+password+]
 		#   login password
 		#
-		# Examples:
+		#
+		# If the Ruby default internal encoding is set (i.e., <code>Encoding.default_internal != nil</code>), the
+		# connection will have its +client_encoding+ set accordingly.
+		#
+		# Raises a PG::Error if the connection fails.
+		#
+		# === Examples:
 		#
 		#   # Connect using all defaults
 		#   PG::Connection.new
@@ -796,10 +855,18 @@ class PG::Connection
 		#   # As an URI
 		#   PG::Connection.new( "postgresql://user:pass@pgsql.example.com:5432/testdb?sslmode=require" )
 		#
-		# If the Ruby default internal encoding is set (i.e., <code>Encoding.default_internal != nil</code>), the
-		# connection will have its +client_encoding+ set accordingly.
+		# === Specifying Multiple Hosts
+		#
+		# It is possible to specify multiple hosts to connect to, so that they are tried in the given order or optionally in random order.
+		# In the Keyword/Value format, the host, hostaddr, and port options accept comma-separated lists of values.
+		# The {details to libpq}[https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-MULTIPLE-HOSTS] describe how it works, but there are two small differences how ruby-pg handles multiple hosts:
+		# - All hosts are resolved before the first connection is tried.
+		#   This means that when +load_balance_hosts+ is set to +random+, then all resolved addresses are tried randomly in one level.
+		#   When a host resolves to more than one address, it is therefore tried more often than a host that has only one address.
+		# - When a timeout occurs due to the value of +connect_timeout+, then the given +host+, +hostaddr+ and +port+ combination is not tried a second time, even if it's specified several times.
+		#   It's still possible to do load balancing with +load_balance_hosts+ set to +random+ and to increase the number of connections a node gets, when the hostname is provided multiple times in the host string.
+		#   This is because in non-timeout cases the host is tried multiple times.
 		#
-		# Raises a PG::Error if the connection fails.
 		def new(*args)
 			conn = connect_to_hosts(*args)
 
@@ -857,7 +924,7 @@ class PG::Connection
 			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 PG::BUNDLED_LIBPQ_WITH_UNIXSOCKET && iopts[:host].to_s.empty?
+			if PG::BUNDLED_LIBPQ_WITH_UNIXSOCKET && iopts[:host].to_s.empty? && iopts[:hostaddr].to_s.empty?
 				# Many distors patch the hardcoded default UnixSocket path in libpq to /var/run/postgresql instead of /tmp .
 				# We simply try them all.
 				iopts[:host] = "/var/run/postgresql" + # Ubuntu, Debian, Fedora, Opensuse

data/lib/pg/version.rb

@@ -1,4 +1,4 @@
 module PG
 	# Library version
-	VERSION = '1.6.0.rc1'
+	VERSION = '1.6.0'
 end

data/misc/yugabyte/Dockerfile

@@ -0,0 +1,9 @@
+FROM yugabytedb/yugabyte:2024.1.0.0-b129
+
+WORKDIR /app
+
+RUN yugabyted cert generate_server_certs --hostnames=127.0.0.1 --base_dir=.
+
+ENTRYPOINT ["yugabyted"]
+CMD ["start", "--background", "false", "--ui", "false", "--tserver_flags", "use_client_to_server_encryption=true,cert_node_filename=127.0.0.1,certs_dir=/app/generated_certs/127.0.0.1"]
+VOLUME /app

data/misc/yugabyte/docker-compose.yml

@@ -0,0 +1,28 @@
+services:
+  yb:
+    build: .
+    container_name: yb
+    ports:
+      - "127.0.0.1:5433:5433"
+    volumes:
+      - certs:/app/generated_certs
+    healthcheck:
+      test: 'ysqlsh -h $$(hostname) -c \\conninfo || exit 1;'
+      interval: 2s
+      timeout: 30s
+      retries: 20
+      start_period: 10s
+
+  pg:
+    image: ruby:3.0
+    working_dir: /app
+    volumes:
+      - .:/app
+      - certs:/generated_certs
+    command: bash -c "gem inst pg-*.gem && ruby pg-test.rb"
+    depends_on:
+      yb:
+        condition: service_healthy
+
+volumes:
+  certs:

data/misc/yugabyte/pg-test.rb

@@ -0,0 +1,45 @@
+require 'pg'
+
+conn = PG.connect(
+  host: 'yb',
+  port: 5433,
+  user: 'yugabyte',
+  dbname: 'yugabyte',
+  sslmode: 'require',
+  sslrootcert: 'app/generated_certs/127.0.0.1/ca.crt',
+  sslcert: 'app/generated_certs/127.0.0.1/node.127.0.0.1.crt',
+  sslkey: 'app/generated_certs/127.0.0.1/node.127.0.0.1.key'
+)
+
+$stdout.sync = true
+# fd = File.open("pg_trace.log", "a+")
+# conn.trace(fd)
+
+begin
+  # Validate connection is working
+  res = conn.exec("SELECT version();")
+  res.each_row do |row|
+    puts "You are connected to: #{row[0]}"
+  end
+# 53*511
+# 53*767
+# 53*1023
+# 53*1279
+# 7*1817
+# 11*1487
+# 13*1363
+# 16*1211
+# 18*1128
+# 22*1984
+# 27*1723
+
+  (22..53).each do |m|
+    (1..2048).each do |l|
+      hanging_query = "SELECT lpad(''::text, #{m}, '0') FROM generate_series(1, #{l});"
+      puts "Executing hanging query: #{hanging_query}"
+      conn.exec(hanging_query)
+    end
+  end
+ensure
+  conn.close if conn
+end

data/pg.gemspec

@@ -17,8 +17,10 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/ged/ruby-pg"
-  spec.metadata["changelog_uri"] = "https://github.com/ged/ruby-pg/blob/master/History.md"
+  spec.metadata["changelog_uri"] = "https://github.com/ged/ruby-pg/blob/master/CHANGELOG.md"
   spec.metadata["documentation_uri"] = "http://deveiate.org/code/pg"
+  # https://github.com/oneclick/rubyinstaller2/wiki/For-gem-developers#msys2-library-dependency
+  spec.metadata["msys2_mingw_dependencies"] = "postgresql"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/ports/patches/krb5/1.21.3/0001-Allow-static-linking-krb5-library.patch

@@ -0,0 +1,30 @@
+From e82c1b395162ea71279ea2170259383082e41ab0 Mon Sep 17 00:00:00 2001
+From: Lars Kanis <lars@greiz-reinsdorf.de>
+Date: Sat, 12 Jul 2025 10:55:17 +0200
+Subject: [PATCH] Allow static linking krb5 library
+
+Otherwise it fails with:
+  Undefined symbols for architecture arm64:
+    "_krb5int_c_mit_des_zeroblock", referenced from:
+      _krb5int_des3_cbc_encrypt in libk5crypto.a(d3_aead.o)
+      _krb5int_des3_cbc_decrypt in libk5crypto.a(d3_aead.o)
+---
+ src/lib/crypto/builtin/des/des_int.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/lib/crypto/builtin/des/des_int.h b/src/lib/crypto/builtin/des/des_int.h
+index 46fed7dbd..114e48ebd 100644
+--- a/lib/crypto/builtin/des/des_int.h
++++ b/lib/crypto/builtin/des/des_int.h
+@@ -159,7 +159,7 @@ mit_des_cbc_encrypt(const mit_des_cblock *in, mit_des_cblock *out,
+                     const mit_des_cblock ivec, int enc);
+ 
+ #define mit_des_zeroblock krb5int_c_mit_des_zeroblock
+-extern const mit_des_cblock mit_des_zeroblock;
++const mit_des_cblock mit_des_zeroblock;
+ 
+ /* fin_rndkey.c */
+ krb5_error_code mit_des_finish_random_key(const krb5_encrypt_block *,
+-- 
+2.43.0
+

data/ports/patches/openssl/3.5.1/0001-aarch64-mingw.patch

@@ -0,0 +1,21 @@
+--- a/Configurations/10-main.conf
++++ b/Configurations/10-main.conf
+@@ -1603,6 +1603,18 @@
+         multilib         => "64",
+     },
+ 
++    "mingwarm64" => {
++        inherit_from     => [ "mingw-common" ],
++        cflags           => "",
++        sys_id           => "MINGWARM64",
++        bn_ops           => add("SIXTY_FOUR_BIT"),
++        asm_arch         => 'aarch64',
++        uplink_arch      => 'armv8',
++        perlasm_scheme   => "win64",
++        shared_rcflag    => "",
++        multilib         => "-arm64",
++    },
++
+ #### UEFI
+     "UEFI" => {
+         inherit_from     => [ "BASE_unix" ],

data/ports/patches/postgresql/17.5/0001-Use-workaround-of-__builtin_setjmp-only-on-MINGW-on-.patch

@@ -0,0 +1,42 @@
+From 746e8e250b265c40d9706f26560e02e8623f123f Mon Sep 17 00:00:00 2001
+From: Lars Kanis <lars@greiz-reinsdorf.de>
+Date: Fri, 31 Jan 2025 21:58:00 +0100
+Subject: [PATCH] Use workaround of __builtin_setjmp only on MINGW on MSVCRT
+
+Because it is not present on ARM64 on Windows and not necessary on any UCRT based toolchain.
+---
+ src/include/c.h | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+diff --git a/src/include/c.h b/src/include/c.h
+index a14c631516..33792c860c 100644
+--- a/src/include/c.h
++++ b/src/include/c.h
+@@ -1312,19 +1312,19 @@ extern int	fdatasync(int fildes);
+ /*
+  * When there is no sigsetjmp, its functionality is provided by plain
+  * setjmp.  We now support the case only on Windows.  However, it seems
+- * that MinGW-64 has some longstanding issues in its setjmp support,
+- * so on that toolchain we cheat and use gcc's builtins.
++ * that MinGW-64 on x86_64 has some longstanding issues in its setjmp
++ * support, so on that toolchain we cheat and use gcc's builtins.
+  */
+ #ifdef WIN32
+-#ifdef __MINGW64__
++#if defined(__MINGW64__) && !defined(_UCRT)
+ typedef intptr_t sigjmp_buf[5];
+ #define sigsetjmp(x,y) __builtin_setjmp(x)
+ #define siglongjmp __builtin_longjmp
+-#else							/* !__MINGW64__ */
++#else							/* !defined(__MINGW64__) || defined(_UCRT) */
+ #define sigjmp_buf jmp_buf
+ #define sigsetjmp(x,y) setjmp(x)
+ #define siglongjmp longjmp
+-#endif							/* __MINGW64__ */
++#endif							/* defined(__MINGW64__) && !defined(_UCRT) */
+ #endif							/* WIN32 */
+ 
+ /* /port compatibility functions */
+-- 
+2.43.0
+

data/ports/patches/postgresql/17.5/0001-libpq-Process-buffered-SSL-read-bytes-to-support-rec.patch

@@ -0,0 +1,52 @@
+From ab793829a4ce473f1cc2bbc0e2a6f6753553255d Mon Sep 17 00:00:00 2001
+From: Lars Kanis <lars@greiz-reinsdorf.de>
+Date: Sun, 8 Sep 2024 13:59:05 +0200
+Subject: [PATCH] libpq: Process buffered SSL read bytes to support records
+ >8kB on async API
+
+The async API of libpq doesn't support SSL record sizes >8kB so far.
+This size isn't exceeded by vanilla PostgreSQL, but by other products using
+the postgres wire protocol 3.
+PQconsumeInput() reads all data readable from the socket, so that the read
+condition is cleared.
+But it doesn't process all the data that is pending on the SSL layer.
+Also a subsequent call to PQisBusy() doesn't process it, so that the client
+is triggered to wait for more readable data on the socket.
+But this never arrives, so that the connection blocks infinitely.
+
+To fix this issue call pqReadData() repeatedly until there is no buffered
+SSL data left to be read.
+
+The synchronous libpq API isn't affected, since it supports arbitrary SSL
+record sizes already.
+---
+ src/interfaces/libpq/fe-exec.c | 13 +++++++++++++
+ 1 file changed, 13 insertions(+)
+
+diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
+index 0d224a852..637894ee1 100644
+--- a/src/interfaces/libpq/fe-exec.c
++++ b/src/interfaces/libpq/fe-exec.c
+@@ -2006,6 +2006,19 @@ PQconsumeInput(PGconn *conn)
+ 	if (pqReadData(conn) < 0)
+ 		return 0;
+ 
++	#ifdef USE_SSL
++		/*
++		 * Ensure all buffered read bytes in the SSL library are processed,
++		 * which might be not the case, if the SSL record size exceeds 8k.
++		 * Otherwise parseInput can't process the data.
++		 */
++		while (conn->ssl_in_use && pgtls_read_pending(conn))
++		{
++			if (pqReadData(conn) < 0)
++				return 0;
++		}
++	#endif
++
+ 	/* Parsing of the data waits till later. */
+ 	return 1;
+ }
+-- 
+2.43.0
+

data/rakelib/pg_gem_helper.rb

@@ -0,0 +1,64 @@
+require 'bundler'
+require 'bundler/gem_helper'
+
+class PgGemHelper < Bundler::GemHelper
+  attr_accessor :cross_platforms
+
+  def install
+    super
+
+    task "release:guard_clean" => ["release:update_history"]
+
+    task "release:update_history" do
+      update_history
+    end
+
+    task "release:rubygem_push" => ["gem:native"]
+  end
+
+  def hfile
+    "CHANGELOG.md"
+  end
+
+  def headline
+    '^([^\n]*)(\d+\.\d+\.\d+(?:\.\w+)?)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
+  end
+
+  def reldate
+    Time.now.strftime("%Y-%m-%d")
+  end
+
+  def update_history
+    hin = File.read(hfile)
+    hout = hin.sub(/#{headline}/) do
+      raise "#{hfile} isn't up-to-date for version #{version} (!= #{$2})" unless $2==version.to_s
+      $1 + $2 + $3 + reldate + $5
+    end
+    if hout != hin
+      Bundler.ui.confirm "Updating #{hfile} for release."
+      File.write(hfile, hout)
+      Rake::FileUtilsExt.sh "git", "commit", hfile, "-m", "Update release date in #{hfile}"
+    end
+  end
+
+  def tag_version
+    Bundler.ui.confirm "Tag release with annotation:"
+    m = File.read(hfile).match(/(?<annotation>#{headline}.*?)#{headline}/m) || raise("Unable to find release notes in #{hfile}")
+    Bundler.ui.info(m[:annotation].gsub(/^/, "    "))
+    IO.popen(["git", "tag", "--file=-", version_tag], "w") do |fd|
+      fd.write m[:annotation]
+    end
+    yield if block_given?
+  rescue
+    Bundler.ui.error "Untagging #{version_tag} due to error."
+    Rake::FileUtilsExt.sh "git", "tag", "-d", version_tag
+    raise
+  end
+
+  def rubygem_push(path)
+    cross_platforms.each do |ruby_platform|
+      super(path.gsub(/\.gem\z/, "-#{ruby_platform}.gem"))
+    end
+    super(path)
+  end
+end