pg 1.2.3-x86-mingw32 → 1.3.0.rc1-x86-mingw32

data/lib/pg/connection.rb

@@ -3,6 +3,8 @@
 
 require 'pg' unless defined?( PG )
 require 'uri'
+require 'io/wait'
+require 'socket'
 
 # The PostgreSQL connection class. The interface for this class is based on
 # {libpq}[http://www.postgresql.org/docs/9.2/interactive/libpq.html], the C
@@ -25,62 +27,140 @@ class PG::Connection
 	CONNECT_ARGUMENT_ORDER = %w[host port options tty dbname user password]
 
 
-	### Quote the given +value+ for use in a connection-parameter string.
-	def self::quote_connstr( value )
+	### Quote a single +value+ for use in a connection-parameter string.
+	def self.quote_connstr( value )
 		return "'" + value.to_s.gsub( /[\\']/ ) {|m| '\\' + m } + "'"
 	end
 
+	# Convert Hash options to connection String
+	#
+	# Values are properly quoted and escaped.
+	def self.connect_hash_to_string( hash )
+		hash.map { |k,v| "#{k}=#{quote_connstr(v)}" }.join( ' ' )
+	end
 
-	### Parse the connection +args+ into a connection-parameter string. See PG::Connection.new
-	### for valid arguments.
-	def self::parse_connect_args( *args )
-		return '' if args.empty?
-
-		hash_arg = args.last.is_a?( Hash ) ? args.pop : {}
-		option_string = ''
+	# Decode a connection string to Hash options
+	#
+	# Value are properly unquoted and unescaped.
+	def self.connect_string_to_hash( str )
 		options = {}
-
-		# Parameter 'fallback_application_name' was introduced in PostgreSQL 9.0
-		# together with PQescapeLiteral().
-		if PG::Connection.instance_methods.find {|m| m.to_sym == :escape_literal }
-			options[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
+		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.
+	#
+	# It accepts:
+	# * an option String kind of "host=name port=5432"
+	# * an option Hash kind of {host: "name", port: 5432}
+	# * URI string
+	# * 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 )
+		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, /\A#{URI::ABS_URI_REF}\z/
-				uri = URI(args.first)
-				options.merge!( Hash[URI.decode_www_form( uri.query )] ) if uri.query
+			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 = HOST_AND_PORT.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 = {}
 			else
-				# Positional parameters
-				options[CONNECT_ARGUMENT_ORDER.first.to_sym] = args.first
+				# Positional parameters (only host given)
+				iopts[CONNECT_ARGUMENT_ORDER.first.to_sym] = args.first
+				oopts = iopts.dup
 			end
 		else
+			# Positional parameters
 			max = CONNECT_ARGUMENT_ORDER.length
 			raise ArgumentError,
 				"Extra positional parameter %d: %p" % [ max + 1, args[max] ] if args.length > max
 
 			CONNECT_ARGUMENT_ORDER.zip( args ) do |(k,v)|
-				options[ k.to_sym ] = v if 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
 
-		options.merge!( hash_arg )
+		if !iopts[:fallback_application_name]
+			oopts[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
+		end
 
 		if uri
-			uri.host     = nil if options[:host]
-			uri.port     = nil if options[:port]
-			uri.user     = nil if options[:user]
-			uri.password = nil if options[:password]
-			uri.path     = '' if options[:dbname]
-			uri.query    = URI.encode_www_form( options )
-			return uri.to_s.sub( /^#{uri.scheme}:(?!\/\/)/, "#{uri.scheme}://" )
+			uri += uri_match['query'] ? "&" : "?"
+			uri += URI.encode_www_form( oopts )
+			return uri
 		else
-			option_string += ' ' unless option_string.empty? && options.empty?
-			return option_string + options.map { |k,v| "#{k}=#{quote_connstr(v)}" }.join( ' ' )
+			option_string += ' ' unless option_string.empty? && oopts.empty?
+			return option_string + connect_hash_to_string(oopts)
 		end
 	end
 
@@ -88,7 +168,7 @@ class PG::Connection
 	#  call-seq:
 	#     conn.copy_data( sql [, coder] ) {|sql_result| ... } -> PG::Result
 	#
-	# Execute a copy process for transfering data to or from the server.
+	# Execute a copy process for transferring data to or from the server.
 	#
 	# This issues the SQL COPY command via #exec. The response to this
 	# (if there is no error in the command) is a PG::Result object that
@@ -214,6 +294,25 @@ class PG::Connection
 		define_method( :isthreadsafe, &PG.method(:isthreadsafe) )
 	end
 
+	#
+	# call-seq:
+	#    conn.transaction { |conn| ... } -> result of the block
+	#
+	# Executes a +BEGIN+ at the start of the block,
+	# and a +COMMIT+ at the end of the block, or
+	# +ROLLBACK+ if any exception occurs.
+	def transaction
+		exec "BEGIN"
+		res = yield(self)
+	rescue Exception
+		cancel if transaction_status != PG::PQTRANS_IDLE
+		block
+		exec "ROLLBACK"
+		raise
+	else
+		exec "COMMIT"
+		res
+	end
 
 	### Returns an array of Hashes with connection defaults. See ::conndefaults
 	### for details.
@@ -237,17 +336,13 @@ class PG::Connection
 		return self.class.conndefaults_hash
 	end
 
-	# Method 'conninfo' was introduced in PostgreSQL 9.3.
-	if self.instance_methods.find{|m| m.to_sym == :conninfo }
-
-		### Return the Postgres connection info structure as a Hash keyed by option
-		### keyword (as a Symbol).
-		###
-		### See also #conninfo
-		def conninfo_hash
-			return self.conninfo.each_with_object({}) do |info, hash|
-				hash[ info[:keyword].to_sym ] = info[:val]
-			end
+	### Return the Postgres connection info structure as a Hash keyed by option
+	### keyword (as a Symbol).
+	###
+	### See also #conninfo
+	def conninfo_hash
+		return self.conninfo.each_with_object({}) do |info, hash|
+			hash[ info[:keyword].to_sym ] = info[:val]
 		end
 	end
 
@@ -269,20 +364,238 @@ class PG::Connection
 		end
 	end
 
-	REDIRECT_METHODS = {
-		:exec => [:async_exec, :sync_exec],
-		:query => [:async_exec, :sync_exec],
-		:exec_params => [:async_exec_params, :sync_exec_params],
-		:prepare => [:async_prepare, :sync_prepare],
-		:exec_prepared => [:async_exec_prepared, :sync_exec_prepared],
-		:describe_portal => [:async_describe_portal, :sync_describe_portal],
-		:describe_prepared => [:async_describe_prepared, :sync_describe_prepared],
-	}
-
-	def self.async_api=(enable)
-		REDIRECT_METHODS.each do |ali, (async, sync)|
-			remove_method(ali) if method_defined?(ali)
-			alias_method( ali, enable ? async : sync )
+	alias sync_get_result get_result
+	def async_get_result(*args)
+		block
+		sync_get_result
+	end
+
+	alias sync_get_copy_data get_copy_data
+	def async_get_copy_data(async=false, decoder=nil)
+		if async
+			return sync_get_copy_data(async, decoder)
+		else
+			while (res=sync_get_copy_data(true, decoder)) == false
+				socket_io.wait_readable
+				consume_input
+			end
+			return res
+		end
+	end
+
+	# In async_api=false mode all send calls run directly on libpq.
+	# Blocking vs. nonblocking state can be changed in libpq.
+	alias sync_setnonblocking setnonblocking
+
+	# In async_api=true mode (default) all send calls run nonblocking.
+	# The difference is that setnonblocking(true) disables automatic handling of would-block cases.
+	def async_setnonblocking(enabled)
+		singleton_class.async_send_api = !enabled
+		self.flush_data = !enabled
+		sync_setnonblocking(true)
+	end
+
+	# sync/async isnonblocking methods are switched by async_setnonblocking()
+	alias sync_isnonblocking isnonblocking
+	def async_isnonblocking
+		false
+	end
+
+	alias sync_put_copy_data put_copy_data
+	def async_put_copy_data(buffer, encoder=nil)
+		until sync_put_copy_data(buffer, encoder)
+			flush
+		end
+		flush
+	end
+	alias sync_put_copy_end put_copy_end
+	def async_put_copy_end(*args)
+		until sync_put_copy_end(*args)
+			flush
+		end
+		flush
+	end
+
+	if method_defined? :encrypt_password
+		alias sync_encrypt_password encrypt_password
+		def async_encrypt_password( password, username, algorithm=nil )
+			algorithm ||= exec("SHOW password_encryption").getvalue(0,0)
+			sync_encrypt_password(password, username, algorithm)
+		end
+	end
+
+	alias sync_reset reset
+	def async_reset
+		reset_start
+		async_connect_or_reset(:reset_poll)
+	end
+
+	alias sync_cancel cancel
+	def async_cancel
+		be_pid = backend_pid
+		be_key = backend_key
+		cancel_request = [0x10, 1234, 5678, be_pid, be_key].pack("NnnNN")
+
+		if Fiber.respond_to?(:scheduler) && Fiber.scheduler && RUBY_PLATFORM =~ /mingw|mswin/
+			# Ruby's nonblocking IO is not really supported on Windows.
+			# We work around by using threads and explicit calls to wait_readable/wait_writable.
+			cl = Thread.new(socket_io.remote_address) { |ra| ra.connect }.value
+			begin
+				cl.write_nonblock(cancel_request)
+			rescue IO::WaitReadable, Errno::EINTR
+				cl.wait_writable
+				retry
+			end
+			begin
+				cl.read_nonblock(1)
+			rescue IO::WaitReadable, Errno::EINTR
+				cl.wait_readable
+				retry
+			rescue EOFError
+			end
+		elsif RUBY_ENGINE == 'truffleruby'
+			begin
+				cl = socket_io.remote_address.connect
+			rescue NotImplementedError
+				# Workaround for truffleruby < 21.3.0
+				cl2 = Socket.for_fd(socket_io.fileno)
+				cl2.autoclose = false
+				adr = cl2.remote_address
+				if adr.ip?
+					cl = TCPSocket.new(adr.ip_address, adr.ip_port)
+					cl.autoclose = false
+				else
+					cl = UNIXSocket.new(adr.unix_path)
+					cl.autoclose = false
+				end
+			end
+			cl.write(cancel_request)
+			cl.read(1)
+		else
+			cl = socket_io.remote_address.connect
+			# Send CANCEL_REQUEST_CODE and parameters
+			cl.write(cancel_request)
+			# Wait for the postmaster to close the connection, which indicates that it's processed the request.
+			cl.read(1)
+		end
+
+		cl.close
+		nil
+	rescue SystemCallError => err
+		err.to_s
+	end
+
+	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 ||
+				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
+
+			# ...and the same for when the socket needs to write
+			when PG::PGRES_POLLING_WRITING
+				socket.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
+
+		# 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
+		alias sync_connect new
+
+		def async_connect(*args, **kwargs)
+			conn = PG::Connection.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)
+		end
+
+		alias sync_ping ping
+		def async_ping(*args)
+			if Fiber.respond_to?(:scheduler) && Fiber.scheduler
+				# Run PQping in a second thread to avoid blocking of the scheduler.
+				# Unfortunately there's no nonblocking way to run ping.
+				Thread.new { sync_ping(*args) }.value
+			else
+				sync_ping(*args)
+			end
+		end
+
+		REDIRECT_CLASS_METHODS = {
+			:new => [:async_connect, :sync_connect],
+			:ping => [:async_ping, :sync_ping],
+		}
+
+		# These methods are affected by PQsetnonblocking
+		REDIRECT_SEND_METHODS = {
+			: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],
+		}
+		REDIRECT_METHODS = {
+			:exec => [:async_exec, :sync_exec],
+			:query => [:async_exec, :sync_exec],
+			:exec_params => [:async_exec_params, :sync_exec_params],
+			:prepare => [:async_prepare, :sync_prepare],
+			:exec_prepared => [:async_exec_prepared, :sync_exec_prepared],
+			:describe_portal => [:async_describe_portal, :sync_describe_portal],
+			:describe_prepared => [:async_describe_prepared, :sync_describe_prepared],
+			:setnonblocking => [:async_setnonblocking, :sync_setnonblocking],
+			:get_result => [:async_get_result, :sync_get_result],
+			:get_last_result => [:async_get_last_result, :sync_get_last_result],
+			:get_copy_data => [:async_get_copy_data, :sync_get_copy_data],
+			:reset => [:async_reset, :sync_reset],
+			:set_client_encoding => [:async_set_client_encoding, :sync_set_client_encoding],
+			:client_encoding= => [:async_set_client_encoding, :sync_set_client_encoding],
+			:cancel => [:async_cancel, :sync_cancel],
+		}
+
+		if PG::Connection.instance_methods.include? :async_encrypt_password
+			REDIRECT_METHODS.merge!({
+				:encrypt_password => [:async_encrypt_password, :sync_encrypt_password],
+			})
+		end
+
+		def async_send_api=(enable)
+			REDIRECT_SEND_METHODS.each do |ali, (async, sync)|
+				undef_method(ali) if method_defined?(ali)
+				alias_method( ali, enable ? async : sync )
+			end
+		end
+
+		def async_api=(enable)
+			self.async_send_api = enable
+			REDIRECT_METHODS.each do |ali, (async, sync)|
+				remove_method(ali) if method_defined?(ali)
+				alias_method( ali, enable ? async : sync )
+			end
+			REDIRECT_CLASS_METHODS.each do |ali, (async, sync)|
+				singleton_class.remove_method(ali) if method_defined?(ali)
+				singleton_class.alias_method(ali, enable ? async : sync )
+			end
 		end
 	end
 

data/lib/pg/version.rb

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

data/lib/pg.rb

@@ -1,15 +1,28 @@
+
 # -*- ruby -*-
 # frozen_string_literal: true
 
-begin
-	require 'pg_ext'
-rescue LoadError
-	# If it's a Windows binary gem, try the <major>.<minor> subdirectory
-	if RUBY_PLATFORM =~/(mswin|mingw)/i
-		major_minor = RUBY_VERSION[ /^(\d+\.\d+)/ ] or
-			raise "Oops, can't extract the major/minor version from #{RUBY_VERSION.dump}"
+# The top-level PG namespace.
+module PG
+
+	# Is this file part of a fat binary gem with bundled libpq?
+	bundled_libpq_path = File.join(__dir__, RUBY_PLATFORM.gsub(/^i386-/, "x86-"))
+	if File.exist?(bundled_libpq_path)
+		POSTGRESQL_LIB_PATH = bundled_libpq_path
+	else
+		bundled_libpq_path = nil
+		# Try to load libpq path as found by extconf.rb
+		begin
+			require "pg/postgresql_lib_path"
+		rescue LoadError
+			# rake-compiler doesn't use regular "make install", but uses it's own install tasks.
+			# It therefore doesn't copy pg/postgresql_lib_path.rb in case of "rake compile".
+			POSTGRESQL_LIB_PATH = false
+		end
+	end
 
-		add_dll_path = proc do |path, &block|
+	add_dll_path = proc do |path, &block|
+		if RUBY_PLATFORM =~/(mswin|mingw)/i && path && File.exist?(path)
 			begin
 				require 'ruby_installer/runtime'
 				RubyInstaller::Runtime.add_dll_directory(path, &block)
@@ -19,28 +32,24 @@ rescue LoadError
 				block.call
 				ENV['PATH'] = old_path
 			end
+		else
+			# No need to set a load path manually - it's set as library rpath.
+			block.call
 		end
+	end
 
-		# Temporary add this directory for DLL search, so that libpq.dll can be found.
-		# mingw32-platform strings differ (RUBY_PLATFORM=i386-mingw32 vs. x86-mingw32 for rubygems)
-		add_dll_path.call(File.join(__dir__, RUBY_PLATFORM.gsub(/^i386-/, "x86-"))) do
+	# Add a load path to the one retrieved from pg_config
+	add_dll_path.call(POSTGRESQL_LIB_PATH) do
+		if bundled_libpq_path
+			# It's a Windows binary gem, try the <major>.<minor> subdirectory
+			major_minor = RUBY_VERSION[ /^(\d+\.\d+)/ ] or
+				raise "Oops, can't extract the major/minor version from #{RUBY_VERSION.dump}"
 			require "#{major_minor}/pg_ext"
+		else
+			require 'pg_ext'
 		end
-	else
-		raise
 	end
 
-end
-
-
-# The top-level PG namespace.
-module PG
-
-	# Library version
-	VERSION = '1.2.3'
-
-	# VCS revision
-	REVISION = %q$Revision: 6f611e78845a $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end
@@ -65,10 +74,14 @@ module PG
 	require 'pg/binary_decoder'
 	require 'pg/text_encoder'
 	require 'pg/text_decoder'
-	require 'pg/basic_type_mapping'
+	require 'pg/basic_type_registry'
+	require 'pg/basic_type_map_based_on_result'
+	require 'pg/basic_type_map_for_queries'
+	require 'pg/basic_type_map_for_results'
 	require 'pg/type_map_by_column'
 	require 'pg/connection'
 	require 'pg/result'
 	require 'pg/tuple'
+	require 'pg/version'
 
 end # module PG

data/misc/openssl-pg-segfault.rb

@@ -0,0 +1,31 @@
+# -*- ruby -*-
+
+PGHOST   = 'localhost'
+PGDB     = 'test'
+#SOCKHOST = 'github.com'
+SOCKHOST = 'it-trac.laika.com'
+
+# Load pg first, so the libssl.so that libpq is linked against is loaded.
+require 'pg'
+$stderr.puts "connecting to postgres://#{PGHOST}/#{PGDB}"
+conn = PG.connect( PGHOST, :dbname => PGDB )
+
+# Now load OpenSSL, which might be linked against a different libssl.
+require 'socket'
+require 'openssl'
+$stderr.puts "Connecting to #{SOCKHOST}"
+sock = TCPSocket.open( SOCKHOST, 443 )
+ctx = OpenSSL::SSL::SSLContext.new
+sock = OpenSSL::SSL::SSLSocket.new( sock, ctx )
+sock.sync_close = true
+
+# The moment of truth...
+$stderr.puts "Attempting to connect..."
+begin
+	sock.connect
+rescue Errno
+	$stderr.puts "Got an error connecting, but no segfault."
+else
+	$stderr.puts "Nope, no segfault!"
+end
+

data/misc/postgres/History.txt

@@ -0,0 +1,9 @@
+== v0.8.0 [2012-02-09] Michael Granger <ged@FaerieMUD.org>
+
+This placeholder version.
+
+
+== v0.7.9.2008.01.28 [2008-01-28] Jeff Davis <<ruby-pg@j-davis.com>>
+
+The last actual version.
+

data/misc/postgres/Manifest.txt

@@ -0,0 +1,5 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/postgres.rb

data/misc/postgres/README.txt

@@ -0,0 +1,21 @@
+= postgres
+
+* https://github.com/ged/ruby-pg
+
+== Description
+
+This is an old, deprecated version of the Ruby PostgreSQL driver that hasn't
+been maintained or supported since early 2008.
+
+You should install/require 'pg' instead.
+
+If you need the 'postgres' gem for legacy code that can't be converted, you can
+still install it using an explicit version, like so:
+
+  gem install postgres -v '0.7.9.2008.01.28'
+  gem uninstall postgres -v '>0.7.9.2008.01.28'
+
+If you have any questions, the nice folks in the Google group can help:
+
+  http://goo.gl/OjOPP / ruby-pg@googlegroups.com
+

data/misc/postgres/Rakefile

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+
+require 'date'
+require 'rubygems'
+require 'hoe'
+require 'pp'
+
+Hoe.spec 'postgres' do
+	self.developer 'Michael Granger', 'ged@FaerieMUD.org'
+	self.dependency 'pg', '~> 0'
+	self.spec_extras[:date] = Date.parse( '2008/01/30' )
+
+	line = '-' * 75
+	msg = paragraphs_of( 'README.txt', 3..-1 )
+	msg.unshift( line )
+	msg.push( line )
+
+	self.spec_extras[:post_install_message] = msg.join( "\n\n" ) + "\n"
+end
+
+# vim: syntax=ruby