pg 0.17.1 → 0.18.4

data/lib/pg/connection.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'pg' unless defined?( PG )
+require 'uri'
 
 # 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
@@ -34,46 +35,55 @@ class PG::Connection
 	def self::parse_connect_args( *args )
 		return '' if args.empty?
 
-		# This will be swapped soon for code that makes options like those required for
-		# PQconnectdbParams()/PQconnectStartParams(). For now, stick to an options string for
-		# PQconnectdb()/PQconnectStart().
+		hash_arg = args.last.is_a?( Hash ) ? args.pop : {}
+		option_string = ''
+		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 }
-			appname = $0.sub(/^(.{30}).{4,}(.{30})$/){ $1+"..."+$2 }
-			appname = PG::Connection.quote_connstr( appname )
-			connopts = ["fallback_application_name=#{appname}"]
-		else
-			connopts = []
+		if PG::Connection.instance_methods.find {|m| m.to_sym == :escape_literal }
+			options[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
 		end
 
-		# Handle an options hash first
-		if args.last.is_a?( Hash )
-			opthash = args.pop
-			opthash.each do |key, val|
-				connopts.push( "%s=%s" % [key, PG::Connection.quote_connstr(val)] )
+		if args.length == 1
+			case args.first
+			when URI, URI.regexp
+				uri = URI(args.first)
+				options.merge!( Hash[URI.decode_www_form( uri.query )] ) if uri.query
+			when /=/
+				# Option string style
+				option_string = args.first.to_s
+			else
+				# Positional parameters
+				options[CONNECT_ARGUMENT_ORDER.first.to_sym] = args.first
 			end
-		end
-
-		# Option string style
-		if args.length == 1 && args.first.to_s.index( '=' )
-			connopts.unshift( args.first )
-
-		# Append positional parameters
 		else
-			args.each_with_index do |val, i|
-				next unless val # Skip nil placeholders
+			max = CONNECT_ARGUMENT_ORDER.length
+			raise ArgumentError,
+				"Extra positional parameter %d: %p" % [ max + 1, args[max] ] if args.length > max
 
-				key = CONNECT_ARGUMENT_ORDER[ i ] or
-					raise ArgumentError, "Extra positional parameter %d: %p" % [ i+1, val ]
-				connopts.push( "%s=%s" % [key, PG::Connection.quote_connstr(val.to_s)] )
+			CONNECT_ARGUMENT_ORDER.zip( args ) do |(k,v)|
+				options[ k.to_sym ] = v if v
 			end
 		end
 
-		return connopts.join(' ')
+		options.merge!( hash_arg )
+
+		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}://" )
+		else
+			option_string += ' ' unless option_string.empty? && options.empty?
+			return option_string + options.map { |k,v| "#{k}=#{quote_connstr(v)}" }.join( ' ' )
+		end
 	end
 
+
 	#  call-seq:
 	#     conn.copy_data( sql ) {|sql_result| ... } -> PG::Result
 	#
@@ -101,7 +111,7 @@ class PG::Connection
 	#
 	# Example with CSV input format:
 	#   conn.exec "create table my_table (a text,b text,c text,d text,e text)"
-	#   conn.copy_data "COPY my_table FROM STDOUT CSV" do
+	#   conn.copy_data "COPY my_table FROM STDIN CSV" do
 	#     conn.put_copy_data "some,csv,data,to,copy\n"
 	#     conn.put_copy_data "more,csv,data,to,copy\n"
 	#   end
@@ -116,12 +126,16 @@ class PG::Connection
 	# This prints all rows of +my_table+ to stdout:
 	#   "some,csv,data,to,copy\n"
 	#   "more,csv,data,to,copy\n"
-	def copy_data( sql )
+	def copy_data( sql, coder=nil )
 		res = exec( sql )
 
 		case res.result_status
 		when PGRES_COPY_IN
 			begin
+				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 ]
@@ -131,10 +145,16 @@ class PG::Connection
 			else
 				put_copy_end
 				get_last_result
+			ensure
+				self.encoder_for_put_copy_data = old_coder if coder
 			end
 
 		when PGRES_COPY_OUT
 			begin
+				if coder
+					old_coder = self.decoder_for_get_copy_data
+					self.decoder_for_get_copy_data = coder
+				end
 				yield res
 			rescue Exception => err
 				cancel
@@ -153,6 +173,8 @@ class PG::Connection
 					raise PG::NotAllCopyDataRetrieved, "Not all COPY data retrieved"
 				end
 				res
+			ensure
+				self.decoder_for_get_copy_data = old_coder if coder
 			end
 
 		else
@@ -172,6 +194,36 @@ class PG::Connection
 		return self.class.conndefaults
 	end
 
+	### Return the Postgres connection defaults structure as a Hash keyed by option
+	### keyword (as a Symbol).
+	###
+	### See also #conndefaults
+	def self.conndefaults_hash
+		return self.conndefaults.each_with_object({}) do |info, hash|
+			hash[ info[:keyword].to_sym ] = info[:val]
+		end
+	end
+
+	### Returns a Hash with connection defaults. See ::conndefaults_hash
+	### for details.
+	def conndefaults_hash
+		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
+		end
+	end
+
 end # class PG::Connection
 
 # Backward-compatible alias

data/lib/pg/result.rb

@@ -5,11 +5,21 @@ require 'pg' unless defined?( PG )
 
 class PG::Result
 
-	### Returns all tuples as an array of arrays
-	def values
-		return enum_for(:each_row).to_a
+	# Apply a type map for all value retrieving methods.
+	#
+	# +type_map+: a PG::TypeMap instance.
+	#
+	# See PG::BasicTypeMapForResults
+	def map_types!(type_map)
+		self.type_map = type_map
+		self
 	end
 
+	def inspect
+		str = self.to_s
+		str[-1,0] = " status=#{res_status(result_status)} ntuples=#{ntuples} nfields=#{nfields} cmd_tuples=#{cmd_tuples}"
+		str
+	end
 end # class PG::Result
 
 # Backward-compatible alias

data/lib/pg/text_decoder.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'date'
+
+module PG
+	module TextDecoder
+		class Date < SimpleDecoder
+			ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+
+			def decode(string, tuple=nil, field=nil)
+				if string =~ ISO_DATE
+					::Date.new $1.to_i, $2.to_i, $3.to_i
+				else
+					string
+				end
+			end
+		end
+
+		class TimestampWithoutTimeZone < SimpleDecoder
+			ISO_DATETIME_WITHOUT_TIMEZONE = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+
+			def decode(string, tuple=nil, field=nil)
+				if string =~ ISO_DATETIME_WITHOUT_TIMEZONE
+					Time.new $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, "#{$6}#{$7}".to_r
+				else
+					string
+				end
+			end
+		end
+
+		class TimestampWithTimeZone < SimpleDecoder
+			ISO_DATETIME_WITH_TIMEZONE = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?([-\+]\d\d):?(\d\d)?:?(\d\d)?\z/
+
+			def decode(string, tuple=nil, field=nil)
+				if string =~ ISO_DATETIME_WITH_TIMEZONE
+					Time.new $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, "#{$6}#{$7}".to_r, "#{$8}:#{$9 || '00'}:#{$10 || '00'}"
+				else
+					string
+				end
+			end
+		end
+	end
+end # module PG
+

data/lib/pg/text_encoder.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+module PG
+	module TextEncoder
+		class Date < SimpleEncoder
+			STRFTIME_ISO_DATE = "%Y-%m-%d".freeze
+			def encode(value)
+				value.respond_to?(:strftime) ? value.strftime(STRFTIME_ISO_DATE) : value
+			end
+		end
+
+		class TimestampWithoutTimeZone < SimpleEncoder
+			STRFTIME_ISO_DATETIME_WITHOUT_TIMEZONE = "%Y-%m-%d %H:%M:%S.%N".freeze
+			def encode(value)
+				value.respond_to?(:strftime) ? value.strftime(STRFTIME_ISO_DATETIME_WITHOUT_TIMEZONE) : value
+			end
+		end
+
+		class TimestampWithTimeZone < SimpleEncoder
+			STRFTIME_ISO_DATETIME_WITH_TIMEZONE = "%Y-%m-%d %H:%M:%S.%N %:z".freeze
+			def encode(value)
+				value.respond_to?(:strftime) ? value.strftime(STRFTIME_ISO_DATETIME_WITH_TIMEZONE) : value
+			end
+		end
+	end
+end # module PG
+

data/lib/pg/type_map_by_column.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'pg' unless defined?( PG )
+
+class PG::TypeMapByColumn
+	# Returns the type oids of the assigned coders.
+	def oids
+		coders.map{|c| c.oid if c }
+	end
+
+	def inspect
+		type_strings = coders.map{|c| c ? "#{c.name}:#{c.format}" : 'nil' }
+		"#<#{self.class} #{type_strings.join(' ')}>"
+	end
+end

data/lib/pg.rb

@@ -7,7 +7,12 @@ rescue LoadError
 	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}"
+
+		# Set the PATH environment variable, so that libpq.dll can be found.
+		old_path = ENV['PATH']
+		ENV['PATH'] = "#{File.expand_path("../#{RUBY_PLATFORM}", __FILE__)};#{old_path}"
 		require "#{major_minor}/pg_ext"
+		ENV['PATH'] = old_path
 	else
 		raise
 	end
@@ -19,10 +24,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.17.1'
+	VERSION = '0.18.4'
 
 	# VCS revision
-	REVISION = %q$Revision: 22d57e3a2b37 $
+	REVISION = %q$Revision: da42b972b5ab $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end
@@ -43,6 +48,11 @@ module PG
 
 	require 'pg/exceptions'
 	require 'pg/constants'
+	require 'pg/coder'
+	require 'pg/text_encoder'
+	require 'pg/text_decoder'
+	require 'pg/basic_type_mapping'
+	require 'pg/type_map_by_column'
 	require 'pg/connection'
 	require 'pg/result'
 

data/spec/{lib/helpers.rb → helpers.rb}

@@ -9,6 +9,38 @@ TEST_DIRECTORY = Pathname.getwd + "tmp_test_specs"
 
 module PG::TestingHelpers
 
+	### Automatically set up the database when it's used, and wrap a transaction around
+	### examples that don't disable it.
+	def self::included( mod )
+		super
+
+		if mod.respond_to?( :around )
+
+			mod.before( :all ) { @conn = setup_testing_db(described_class ? described_class.name : mod.description) }
+
+			mod.around( :each ) do |example|
+				begin
+					@conn.exec( 'BEGIN' ) unless example.metadata[:without_transaction]
+					if PG.respond_to?( :library_version )
+						desc = example.source_location.join(':')
+						@conn.exec_params %Q{SET application_name TO '%s'} %
+							[@conn.escape_string(desc.slice(-60))]
+					end
+					example.run
+				ensure
+					@conn.exec( 'ROLLBACK' ) unless example.metadata[:without_transaction]
+				end
+			end
+
+			mod.after( :all ) { teardown_testing_db(@conn) }
+		end
+
+	end
+
+
+	#
+	# Examples
+	#
 
 	# Set some ANSI escape code constants (Shamelessly stolen from Perl's
 	# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
@@ -121,28 +153,9 @@ module PG::TestingHelpers
 		end
 
 		# Eliminate the noise of creating/tearing down the database by
-		# redirecting STDERR/STDOUT to a logfile if the Ruby interpreter
-		# supports fork()
+		# redirecting STDERR/STDOUT to a logfile
 		logfh = File.open( logpath, File::WRONLY|File::CREAT|File::APPEND )
-		begin
-			pid = fork
-		rescue NotImplementedError
-			logfh.close
-			system( *cmd )
-		else
-			if pid
-				logfh.close
-			else
-				$stdout.reopen( logfh )
-				$stderr.reopen( $stdout )
-				$stderr.puts( ">>> " + cmd.shelljoin )
-				exec( *cmd )
-				$stderr.puts "After the exec()?!??!"
-				exit!
-			end
-
-			Process.wait( pid )
-		end
+		system( *cmd, [STDOUT, STDERR] => logfh )
 
 		raise "Command failed: [%s]" % [cmd.join(' ')] unless $?.success?
 	end
@@ -242,35 +255,82 @@ module PG::TestingHelpers
 			unless conns.empty?
 				puts "Lingering connections remain:"
 				conns.each do |row|
-					puts "  [%d] {%s} %s -- %s" % row.values_at( 'pid', 'state', 'application_name', 'query' )
+					puts "  [%s] {%s} %s -- %s" % row.values_at( 'pid', 'state', 'application_name', 'query' )
 				end
 			end
 		end
 	end
 
-	def connection_string_should_contain_application_name(conn_args, app_name)
-		conn_name = conn_args.match(/application_name='(.*)'/)[1]
-		conn_name.should include(app_name[0..10])
-		conn_name.should include(app_name[-10..-1])
-		conn_name.length.should <= 64
+
+	# Retrieve the names of the column types of a given result set.
+	def result_typenames(res)
+		@conn.exec( "SELECT " + res.nfields.times.map{|i| "format_type($#{i*2+1},$#{i*2+2})"}.join(","),
+				res.nfields.times.map{|i| [res.ftype(i), res.fmod(i)] }.flatten ).
+				values[0]
+	end
+
+
+	# A matcher for checking the status of a PG::Connection to ensure it's still
+	# usable.
+	class ConnStillUsableMatcher
+
+		def initialize
+			@conn = nil
+			@problem = nil
+		end
+
+		def matches?( conn )
+			@conn = conn
+			@problem = self.check_for_problems
+			return @problem.nil?
+		end
+
+		def check_for_problems
+			return "is finished" if @conn.finished?
+			return "has bad status" unless @conn.status == PG::CONNECTION_OK
+			return "has bad transaction status (%d)" % [ @conn.transaction_status ] unless
+				@conn.transaction_status.between?( PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS )
+			return "is not usable." unless self.can_exec_query?
+			return nil
+		end
+
+		def can_exec_query?
+			@conn.send_query( "VALUES (1)" )
+			@conn.get_last_result.values == [["1"]]
+		end
+
+		def failure_message
+			return "expected %p to be usable, but it %s" % [ @conn, @problem ]
+		end
+
+		def failure_message_when_negated
+			"expected %p not to be usable, but it still is" % [ @conn ]
+		end
+
 	end
 
-	# Ensure the connection is in a clean execution status.
-	def verify_clean_exec_status
-		@conn.send_query( "VALUES (1)" )
-		@conn.get_last_result.values.should == [["1"]]
+
+	### Return a ConnStillUsableMatcher to be used like:
+	###
+	###    expect( pg_conn ).to still_be_usable
+	###
+	def still_be_usable
+		return ConnStillUsableMatcher.new
 	end
+
 end
 
 
 RSpec.configure do |config|
-	ruby_version_vec = RUBY_VERSION.split('.').map {|c| c.to_i }.pack( "N*" )
-
 	config.include( PG::TestingHelpers )
-	config.treat_symbols_as_metadata_keys_with_true_values = true
 
-	config.mock_with :rspec
-	config.filter_run_excluding :ruby_19 if ruby_version_vec <= [1,9,1].pack( "N*" )
+	config.run_all_when_everything_filtered = true
+	config.filter_run :focus
+	config.order = 'random'
+	config.mock_with( :rspec ) do |mock|
+		mock.syntax = :expect
+	end
+
 	if RUBY_PLATFORM =~ /mingw|mswin/
 		config.filter_run_excluding :unix
 	else
@@ -283,11 +343,13 @@ RSpec.configure do |config|
 		PG::Connection.instance_methods.map( &:to_sym ).include?( :escape_literal )
 
 	if !PG.respond_to?( :library_version )
-		config.filter_run_excluding( :postgresql_91, :postgresql_92, :postgresql_93 )
+		config.filter_run_excluding( :postgresql_91, :postgresql_92, :postgresql_93, :postgresql_94 )
 	elsif PG.library_version < 90200
-		config.filter_run_excluding( :postgresql_92, :postgresql_93 )
+		config.filter_run_excluding( :postgresql_92, :postgresql_93, :postgresql_94 )
 	elsif PG.library_version < 90300
-		config.filter_run_excluding( :postgresql_93 )
+		config.filter_run_excluding( :postgresql_93, :postgresql_94 )
+	elsif PG.library_version < 90400
+		config.filter_run_excluding( :postgresql_94 )
 	end
 end