pg 0.17.1-x64-mingw32 → 0.18.0.pre20141017160319-x64-mingw32

data/lib/pg/coder.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+module PG
+
+	class Coder
+		# Create a new coder object based on the attribute Hash.
+		def initialize(params={})
+			params.each do |key, val|
+				send("#{key}=", val)
+			end
+		end
+
+		def dup
+			self.class.new(to_h)
+		end
+
+		# Returns coder attributes as Hash.
+		def to_h
+			{
+				oid: oid,
+				format: format,
+				name: name,
+			}
+		end
+
+		def ==(v)
+			self.class == v.class && to_h == v.to_h
+		end
+
+		def marshal_dump
+			Marshal.dump(to_h)
+		end
+
+		def marshal_load(str)
+			initialize Marshal.load(str)
+		end
+
+		def inspect
+			str = self.to_s
+			oid_str = " oid=#{oid}" unless oid==0
+			format_str = " format=#{format}" unless format==0
+			name_str = " #{name.inspect}" if name
+			str[-1,0] = "#{name_str} #{oid_str}#{format_str}"
+			str
+		end
+	end
+
+	class CompositeCoder < Coder
+		def to_h
+			super.merge!({
+				elements_type: elements_type,
+				needs_quotation: needs_quotation?,
+				delimiter: delimiter,
+			})
+		end
+
+		def inspect
+			str = super
+			str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation"
+			str
+		end
+	end
+
+	class CopyCoder < Coder
+		def to_h
+			super.merge!({
+				type_map: type_map,
+				delimiter: delimiter,
+				null_string: null_string,
+			})
+		end
+	end
+end # module PG
+

data/lib/pg/connection.rb

@@ -116,12 +116,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 +135,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 +163,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 +184,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,42 @@
+#!/usr/bin/env ruby
+
+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
+					Time.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)\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}: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/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
@@ -248,29 +261,76 @@ module PG::TestingHelpers
 		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

data/spec/pg/basic_type_mapping_spec.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/env rspec
+# encoding: utf-8
+
+require_relative '../helpers'
+
+require 'pg'
+
+describe 'Basic type mapping' do
+
+	describe PG::BasicTypeMapForQueries do
+		let!(:basic_type_mapping) do
+			PG::BasicTypeMapForQueries.new @conn
+		end
+
+		#
+		# Encoding Examples
+		#
+
+		it "should do basic param encoding", :ruby_19 do
+			res = @conn.exec_params( "SELECT $1::int8,$2::float,$3,$4::TEXT",
+				[1, 2.1, true, "b"], nil, basic_type_mapping )
+
+			expect( res.values ).to eq( [
+					[ "1", "2.1", "t", "b" ],
+			] )
+
+			expect( result_typenames(res) ).to eq( ['bigint', 'double precision', 'boolean', 'text'] )
+		end
+
+		it "should do array param encoding" do
+			res = @conn.exec_params( "SELECT $1,$2,$3,$4", [
+					[1, 2, 3], [[1, 2], [3, nil]],
+					[1.11, 2.21],
+					['/,"'.gsub("/", "\\"), nil, 'abcäöü'],
+				], nil, basic_type_mapping )
+
+			expect( res.values ).to eq( [[
+					'{1,2,3}', '{{1,2},{3,NULL}}',
+					'{1.11,2.21}',
+					'{"//,/"",NULL,abcäöü}'.gsub("/", "\\"),
+			]] )
+
+			expect( result_typenames(res) ).to eq( ['bigint[]', 'bigint[]', 'double precision[]', 'text[]'] )
+		end
+	end
+
+
+
+	describe PG::BasicTypeMapForResults do
+		let!(:basic_type_mapping) do
+			PG::BasicTypeMapForResults.new @conn
+		end
+
+		#
+		# Decoding Examples
+		#
+
+		it "should do OID based type conversions", :ruby_19 do
+			res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, TRUE, '2013-06-30'::DATE, generate_series(4,5)" )
+			expect( res.map_types!(basic_type_mapping).values ).to eq( [
+					[ 1, 'a', 2.0, true, Time.new(2013,6,30), 4 ],
+					[ 1, 'a', 2.0, true, Time.new(2013,6,30), 5 ],
+			] )
+		end
+
+		#
+		# Decoding Examples text+binary format converters
+		#
+
+		describe "connection wide type mapping" do
+			before :each do
+				@conn.type_map_for_results = basic_type_mapping
+			end
+
+			after :each do
+				@conn.type_map_for_results = nil
+			end
+
+			it "should do boolean type conversions" do
+				[1, 0].each do |format|
+					res = @conn.exec( "SELECT true::BOOLEAN, false::BOOLEAN, NULL::BOOLEAN", [], format )
+					expect( res.values ).to eq( [[true, false, nil]] )
+				end
+			end
+
+			it "should do binary type conversions" do
+				[1, 0].each do |format|
+					res = @conn.exec( "SELECT E'\\\\000\\\\377'::BYTEA", [], format )
+					expect( res.values ).to eq( [[["00ff"].pack("H*")]] )
+					expect( res.values[0][0].encoding ).to eq( Encoding::ASCII_8BIT ) if Object.const_defined? :Encoding
+				end
+			end
+
+			it "should do integer type conversions" do
+				[1, 0].each do |format|
+					res = @conn.exec( "SELECT -8999::INT2, -899999999::INT4, -8999999999999999999::INT8", [], format )
+					expect( res.values ).to eq( [[-8999, -899999999, -8999999999999999999]] )
+				end
+			end
+
+			it "should do string type conversions" do
+				@conn.internal_encoding = 'utf-8' if Object.const_defined? :Encoding
+				[1, 0].each do |format|
+					res = @conn.exec( "SELECT 'abcäöü'::TEXT", [], format )
+					expect( res.values ).to eq( [['abcäöü']] )
+					expect( res.values[0][0].encoding ).to eq( Encoding::UTF_8 ) if Object.const_defined? :Encoding
+				end
+			end
+
+			it "should do float type conversions" do
+				[1, 0].each do |format|
+					res = @conn.exec( "SELECT -8.999e3::FLOAT4,
+														8.999e10::FLOAT4,
+														-8999999999e-99::FLOAT8,
+														NULL::FLOAT4,
+														'NaN'::FLOAT4,
+														'Infinity'::FLOAT4,
+														'-Infinity'::FLOAT4
+													", [], format )
+					expect( res.getvalue(0,0) ).to be_within(1e-2).of(-8.999e3)
+					expect( res.getvalue(0,1) ).to be_within(1e5).of(8.999e10)
+					expect( res.getvalue(0,2) ).to be_within(1e-109).of(-8999999999e-99)
+					expect( res.getvalue(0,3) ).to be_nil
+					expect( res.getvalue(0,4) ).to be_nan
+					expect( res.getvalue(0,5) ).to eq( Float::INFINITY )
+					expect( res.getvalue(0,6) ).to eq( -Float::INFINITY )
+				end
+			end
+
+			it "should do datetime without time zone type conversions" do
+				[0].each do |format|
+					res = @conn.exec( "SELECT CAST('2013-12-31 23:58:59+02' AS TIMESTAMP WITHOUT TIME ZONE),
+																		CAST('1913-12-31 23:58:59.123-03' AS TIMESTAMP WITHOUT TIME ZONE),
+																		CAST('infinity' AS TIMESTAMP WITHOUT TIME ZONE),
+																		CAST('-infinity' AS TIMESTAMP WITHOUT TIME ZONE)", [], format )
+					expect( res.getvalue(0,0) ).to eq( Time.new(2013, 12, 31, 23, 58, 59) )
+					expect( res.getvalue(0,1) ).to be_within(1e-3).of(Time.new(1913, 12, 31, 23, 58, 59.123))
+					expect( res.getvalue(0,2) ).to eq( 'infinity' )
+					expect( res.getvalue(0,3) ).to eq( '-infinity' )
+				end
+			end
+
+			it "should do datetime with time zone type conversions" do
+				[0].each do |format|
+					res = @conn.exec( "SELECT CAST('2013-12-31 23:58:59+02' AS TIMESTAMP WITH TIME ZONE),
+																		CAST('1913-12-31 23:58:59.123-03' AS TIMESTAMP WITH TIME ZONE),
+																		CAST('infinity' AS TIMESTAMP WITH TIME ZONE),
+																		CAST('-infinity' AS TIMESTAMP WITH TIME ZONE)", [], format )
+					expect( res.getvalue(0,0) ).to eq( Time.new(2013, 12, 31, 23, 58, 59, "+02:00") )
+					expect( res.getvalue(0,1) ).to be_within(1e-3).of(Time.new(1913, 12, 31, 23, 58, 59.123, "-03:00"))
+					expect( res.getvalue(0,2) ).to eq( 'infinity' )
+					expect( res.getvalue(0,3) ).to eq( '-infinity' )
+				end
+			end
+
+			it "should do date type conversions" do
+				[0].each do |format|
+					res = @conn.exec( "SELECT CAST('2113-12-31' AS DATE),
+																		CAST('1913-12-31' AS DATE),
+																		CAST('infinity' AS DATE),
+																		CAST('-infinity' AS DATE)", [], format )
+					expect( res.getvalue(0,0) ).to eq( Time.new(2113, 12, 31) )
+					expect( res.getvalue(0,1) ).to eq( Time.new(1913, 12, 31) )
+					expect( res.getvalue(0,2) ).to eq( 'infinity' )
+					expect( res.getvalue(0,3) ).to eq( '-infinity' )
+				end
+			end
+
+			it "should do array type conversions" do
+				[0].each do |format|
+					res = @conn.exec( "SELECT CAST('{1,2,3}' AS INT2[]), CAST('{{1,2},{3,4}}' AS INT2[][]),
+															CAST('{1,2,3}' AS INT4[]),
+															CAST('{1,2,3}' AS INT8[]),
+															CAST('{1,2,3}' AS TEXT[]),
+															CAST('{1,2,3}' AS VARCHAR[]),
+															CAST('{1,2,3}' AS FLOAT4[]),
+															CAST('{1,2,3}' AS FLOAT8[])
+														", [], format )
+					expect( res.getvalue(0,0) ).to eq( [1,2,3] )
+					expect( res.getvalue(0,1) ).to eq( [[1,2],[3,4]] )
+					expect( res.getvalue(0,2) ).to eq( [1,2,3] )
+					expect( res.getvalue(0,3) ).to eq( [1,2,3] )
+					expect( res.getvalue(0,4) ).to eq( ['1','2','3'] )
+					expect( res.getvalue(0,5) ).to eq( ['1','2','3'] )
+					expect( res.getvalue(0,6) ).to eq( [1.0,2.0,3.0] )
+					expect( res.getvalue(0,7) ).to eq( [1.0,2.0,3.0] )
+				end
+			end
+		end
+
+		context "with usage of result oids for copy decoder selection" do
+			it "can type cast #copy_data output with explicit decoder" do
+				@conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, ai INT[])" )
+				@conn.exec( "INSERT INTO copytable VALUES ('a', 123, '{5,4,3}'), ('b', 234, '{2,3}')" )
+
+				# Retrieve table OIDs per empty result.
+				res = @conn.exec( "SELECT * FROM copytable LIMIT 0" )
+				tm = basic_type_mapping.fit_to_result( res, false )
+				row_decoder = PG::TextDecoder::CopyRow.new type_map: tm
+
+				rows = []
+				@conn.copy_data( "COPY copytable TO STDOUT", row_decoder ) do |res|
+					while row=@conn.get_copy_data
+						rows << row
+					end
+				end
+				expect( rows ).to eq( [['a', 123, [5,4,3]], ['b', 234, [2,3]]] )
+			end
+		end
+	end
+
+
+	describe PG::BasicTypeMapBasedOnResult do
+		let!(:basic_type_mapping) do
+			PG::BasicTypeMapBasedOnResult.new @conn
+		end
+
+		context "with usage of result oids for bind params encoder selection" do
+			it "can type cast query params" do
+				@conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, ai INT[])" )
+
+				# Retrieve table OIDs per empty result.
+				res = @conn.exec( "SELECT * FROM copytable LIMIT 0" )
+				tm = basic_type_mapping.fit_to_result( res, false )
+
+				@conn.exec_params( "INSERT INTO copytable VALUES ($1, $2, $3)", ['a', 123, [5,4,3]], 0, tm )
+				@conn.exec_params( "INSERT INTO copytable VALUES ($1, $2, $3)", ['b', 234, [2,3]], 0, tm )
+				res = @conn.exec( "SELECT * FROM copytable" )
+				expect( res.values ).to eq( [['a', '123', '{5,4,3}'], ['b', '234', '{2,3}']] )
+			end
+		end
+
+		context "with usage of result oids for copy encoder selection" do
+			it "can type cast #copy_data input with explicit encoder" do
+				@conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, ai INT[])" )
+
+				# Retrieve table OIDs per empty result set.
+				res = @conn.exec( "SELECT * FROM copytable LIMIT 0" )
+				tm = basic_type_mapping.fit_to_result( res, false )
+				row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
+
+				@conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|
+					@conn.put_copy_data ['a', 123, [5,4,3]]
+					@conn.put_copy_data ['b', 234, [2,3]]
+				end
+				res = @conn.exec( "SELECT * FROM copytable" )
+				expect( res.values ).to eq( [['a', '123', '{5,4,3}'], ['b', '234', '{2,3}']] )
+			end
+		end
+	end
+end