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

data/lib/pg.rb

@@ -10,7 +10,7 @@ rescue LoadError
 
 		# Set the PATH environment variable, so that libpq.dll can be found.
 		old_path = ENV['PATH']
-		ENV['PATH'] = "#{old_path};#{File.expand_path("../#{RUBY_PLATFORM}", __FILE__)}"
+		ENV['PATH'] = "#{File.expand_path("../#{RUBY_PLATFORM}", __FILE__)};#{old_path}"
 		require "#{major_minor}/pg_ext"
 		ENV['PATH'] = old_path
 	else
@@ -24,7 +24,7 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.18.0.pre20141017160319'
+	VERSION = '0.18.0.pre20141117110243'
 
 	# VCS revision
 	REVISION = %q$Revision$

data/lib/pg/basic_type_mapping.rb

@@ -304,7 +304,7 @@ end
 #   # Execute a query. The Integer param value is typecasted internally by PG::BinaryEncoder::Int8.
 #   # The format of the parameter is set to 1 (binary) and the OID of this parameter is set to 20 (int8).
 #   res = conn.exec_params( "SELECT $1", [5] )
-class PG::BasicTypeMapForQueries < PG::TypeMapByMriType
+class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 	include PG::BasicTypeRegistry
 
 	def initialize(connection)
@@ -323,7 +323,7 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByMriType
 	end
 
 	def populate_encoder_list
-		DEFAULT_TYPE_MAP.each do |mri_type, selector|
+		DEFAULT_TYPE_MAP.each do |klass, selector|
 			if Array === selector
 				format, name, oid_name = selector
 				coder = coder_by_name(format, :encoder, name).dup
@@ -332,9 +332,9 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByMriType
 				else
 					coder.oid = 0
 				end
-				self[mri_type] = coder
+				self[klass] = coder
 			else
-				self[mri_type] = selector
+				self[klass] = selector
 			end
 		end
 	end
@@ -351,25 +351,25 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByMriType
 		while elem.kind_of?(Array)
 			elem = elem.first
 		end
-		@array_encoders_by_klass[elem.class] || @anyarray_encoder
+		@array_encoders_by_klass[elem.class] ||
+				elem.class.ancestors.lazy.map{|ancestor| @array_encoders_by_klass[ancestor] }.find{|a| a } ||
+				@anyarray_encoder
 	end
 
 	DEFAULT_TYPE_MAP = {
-		'T_TRUE'.freeze => [1, 'bool', 'bool'],
-		'T_FALSE'.freeze => [1, 'bool', 'bool'],
+		TrueClass => [1, 'bool', 'bool'],
+		FalseClass => [1, 'bool', 'bool'],
 		# We use text format and no type OID for numbers, because setting the OID can lead
 		# to unnecessary type conversions on server side.
-		'T_FIXNUM'.freeze => [0, 'int8'],
-		'T_BIGNUM'.freeze => [0, 'int8'],
-		'T_FLOAT'.freeze => [0, 'float8'],
-		'T_ARRAY'.freeze => :get_array_type,
+		Integer => [0, 'int8'],
+		Float => [0, 'float8'],
+		Array => :get_array_type,
 	}
 
 	DEFAULT_ARRAY_TYPE_MAP = {
 		TrueClass => [0, '_bool'],
 		FalseClass => [0, '_bool'],
-		Fixnum => [0, '_int8'],
-		Bignum => [0, '_int8'],
+		Integer => [0, '_int8'],
 		String => [0, '_text'],
 		Float => [0, '_float8'],
 	}

data/lib/pg/coder.rb

@@ -3,6 +3,15 @@
 module PG
 
 	class Coder
+
+		module BinaryFormatting
+			Params = { format: 1 }
+			def initialize( params={} )
+				super(params.merge(Params))
+			end
+		end
+
+
 		# Create a new coder object based on the attribute Hash.
 		def initialize(params={})
 			params.each do |key, val|

data/spec/helpers.rb

@@ -343,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
 

data/spec/pg/basic_type_mapping_spec.rb

@@ -73,7 +73,7 @@ describe 'Basic type mapping' do
 			end
 
 			after :each do
-				@conn.type_map_for_results = nil
+				@conn.type_map_for_results = PG::TypeMapAllStrings.new
 			end
 
 			it "should do boolean type conversions" do

data/spec/pg/connection_spec.rb

@@ -157,6 +157,17 @@ describe PG::Connection do
 		expect( res[0]['n'] ).to eq( '1' )
 	end
 
+	it "can retrieve it's connection parameters for the established connection" do
+		expect( @conn.db ).to eq( "test" )
+		expect( @conn.user ).to be_a_kind_of( String )
+		expect( @conn.pass ).to eq( "" )
+		expect( @conn.host ).to eq( "localhost" )
+		# TODO: Not sure why libpq returns a NULL ptr instead of "127.0.0.1"
+		expect( @conn.hostaddr ).to eq( nil ) if @conn.server_version >= 9_04_00
+		expect( @conn.port ).to eq( 54321 )
+		expect( @conn.tty ).to eq( "" )
+		expect( @conn.options ).to eq( "" )
+	end
 
 	EXPECTED_TRACE_OUTPUT = %{
 		To backend> Msg Q
@@ -1293,8 +1304,8 @@ describe PG::Connection do
 		end
 
 		it "should return nil if no type mapping is set" do
-			expect( @conn.type_map_for_queries ).to be_nil
-			expect( @conn.type_map_for_results ).to be_nil
+			expect( @conn.type_map_for_queries ).to be_kind_of(PG::TypeMapAllStrings)
+			expect( @conn.type_map_for_results ).to be_kind_of(PG::TypeMapAllStrings)
 		end
 
 		it "shouldn't type map params unless requested" do
@@ -1331,8 +1342,8 @@ describe PG::Connection do
 		context "with default query type map" do
 			before :each do
 				@conn2 = described_class.new(@conninfo)
-				tm = PG::TypeMapByMriType.new
-				tm['T_FIXNUM'] = PG::TextEncoder::Integer.new oid: 20
+				tm = PG::TypeMapByClass.new
+				tm[Integer] = PG::TextEncoder::Integer.new oid: 20
 				@conn2.type_map_for_queries = tm
 
 				row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
@@ -1349,7 +1360,7 @@ describe PG::Connection do
 			end
 
 			it "should return the current type mapping" do
-				expect( @conn2.type_map_for_queries ).to be_kind_of(PG::TypeMapByMriType)
+				expect( @conn2.type_map_for_queries ).to be_kind_of(PG::TypeMapByClass)
 			end
 
 			it "should work with arbitrary number of params in conjunction with type casting" do

data/spec/pg/result_spec.rb

@@ -21,6 +21,80 @@ describe PG::Result do
 		expect( list ).to eq [['1', '2']]
 	end
 
+	it "yields a row as an Enumerator" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		e = res.each_row
+		expect( e ).to be_a_kind_of(Enumerator)
+		pending "Rubinius doesn't define RETURN_SIZED_ENUMERATOR()" if RUBY_ENGINE=='rbx'
+		expect( e.size ).to eq( 1 )
+		expect( e.to_a ).to eq [['1', '2']]
+	end
+
+	it "yields a row as an Enumerator of hashs" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		e = res.each
+		expect( e ).to be_a_kind_of(Enumerator)
+		pending "Rubinius doesn't define RETURN_SIZED_ENUMERATOR()" if RUBY_ENGINE=='rbx'
+		expect( e.size ).to eq( 1 )
+		expect( e.to_a ).to eq [{'a'=>'1', 'b'=>'2'}]
+	end
+
+	context "result streaming", :postgresql_92 do
+		it "can iterate over all tuples in single row mode" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a; SELECT 1 AS b, generate_series(5,6) AS c" )
+			@conn.set_single_row_mode
+			expect(
+				@conn.get_result.stream_each.to_a
+			).to eq(
+				[{'a'=>"2"}, {'a'=>"3"}, {'a'=>"4"}]
+			)
+			expect(
+				@conn.get_result.enum_for(:stream_each).to_a
+			).to eq(
+				[{'b'=>"1", 'c'=>"5"}, {'b'=>"1", 'c'=>"6"}]
+			)
+			expect( @conn.get_result ).to be_nil
+		end
+
+		it "can iterate over all rows in single row mode" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a; SELECT 1 AS b, generate_series(5,6) AS c" )
+			@conn.set_single_row_mode
+			expect(
+				@conn.get_result.enum_for(:stream_each_row).to_a
+			).to eq(
+				[["2"], ["3"], ["4"]]
+			)
+			expect(
+				@conn.get_result.stream_each_row.to_a
+			).to eq(
+				[["1", "5"], ["1", "6"]]
+			)
+			expect( @conn.get_result ).to be_nil
+		end
+
+		it "complains when not in single row mode" do
+			@conn.send_query( "SELECT generate_series(2,4)" )
+			expect{
+				@conn.get_result.stream_each_row.to_a
+			}.to raise_error(PG::InvalidResultStatus, /not in single row mode/)
+		end
+
+		it "complains when intersected with get_result" do
+			@conn.send_query( "SELECT 1" )
+			@conn.set_single_row_mode
+			expect{
+				@conn.get_result.stream_each_row.each{ @conn.get_result }
+			}.to raise_error(PG::NoResultError, /no result received/)
+		end
+
+		it "raises server errors" do
+			@conn.send_query( "SELECT 0/0" )
+			expect{
+				@conn.get_result.stream_each_row.to_a
+			}.to raise_error(PG::DivisionByZero)
+		end
+	end
+
 	it "inserts nil AS NULL and return NULL as nil" do
 		res = @conn.exec("SELECT $1::int AS n", [nil])
 		expect( res[0]['n'] ).to be_nil()
@@ -335,14 +409,14 @@ describe PG::Result do
 
 		it "should allow reading, assigning and diabling type conversions" do
 			res = @conn.exec( "SELECT 123" )
-			expect( res.type_map ).to be_nil
+			expect( res.type_map ).to be_kind_of(PG::TypeMapAllStrings)
 			res.type_map = PG::TypeMapByColumn.new [textdec_int]
 			expect( res.type_map ).to be_an_instance_of(PG::TypeMapByColumn)
 			expect( res.type_map.coders ).to eq( [textdec_int] )
 			res.type_map = PG::TypeMapByColumn.new [textdec_float]
 			expect( res.type_map.coders ).to eq( [textdec_float] )
-			res.type_map = nil
-			expect( res.type_map ).to be_nil
+			res.type_map = PG::TypeMapAllStrings.new
+			expect( res.type_map ).to be_kind_of(PG::TypeMapAllStrings)
 		end
 
 		it "should be applied to all value retrieving methods" do

data/spec/pg/type_map_by_class_spec.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env rspec
+# encoding: utf-8
+
+require_relative '../helpers'
+
+require 'pg'
+
+
+describe PG::TypeMapByClass do
+
+	let!(:textenc_int){ PG::TextEncoder::Integer.new name: 'INT4', oid: 23 }
+	let!(:textenc_float){ PG::TextEncoder::Float.new name: 'FLOAT8', oid: 701 }
+	let!(:textenc_string){ PG::TextEncoder::String.new name: 'TEXT', oid: 25 }
+	let!(:binaryenc_int){ PG::BinaryEncoder::Int8.new name: 'INT8', oid: 20, format: 1 }
+	let!(:pass_through_type) do
+		type = Class.new(PG::SimpleEncoder) do
+			def encode(*v)
+				v.inspect
+			end
+		end.new
+		type.oid = 25
+		type.format = 0
+		type.name = 'pass_through'
+		type
+	end
+
+	let!(:tm) do
+		tm = PG::TypeMapByClass.new
+		tm[Integer] = binaryenc_int
+		tm[Float] = textenc_float
+		tm[Symbol] = pass_through_type
+		tm
+	end
+
+	let!(:raise_class) do
+		Class.new
+	end
+
+	let!(:derived_tm) do
+		tm = Class.new(PG::TypeMapByClass) do
+			def array_type_map_for(value)
+				PG::TextEncoder::Array.new name: '_INT4', oid: 1007, elements_type: PG::TextEncoder::Integer.new
+			end
+		end.new
+		tm[Integer] = proc{|value| textenc_int }
+		tm[raise_class] = proc{|value| /invalid/ }
+		tm[Array] = :array_type_map_for
+		tm
+	end
+
+	it "should retrieve all conversions" do
+		expect( tm.coders ).to eq( {
+			Integer => binaryenc_int,
+			Float => textenc_float,
+			Symbol => pass_through_type,
+		} )
+	end
+
+	it "should retrieve particular conversions" do
+		expect( tm[Integer] ).to eq(binaryenc_int)
+		expect( tm[Float] ).to eq(textenc_float)
+		expect( tm[Bignum] ).to be_nil
+		expect( derived_tm[raise_class] ).to be_kind_of(Proc)
+		expect( derived_tm[Array] ).to eq(:array_type_map_for)
+	end
+
+	it "should allow deletion of coders" do
+		tm[Integer] = nil
+		expect( tm[Integer] ).to be_nil
+		expect( tm.coders ).to eq( {
+			Float => textenc_float,
+			Symbol => pass_through_type,
+		} )
+	end
+
+	it "forwards query param conversions to the #default_type_map" do
+		tm1 = PG::TypeMapByColumn.new( [textenc_int, nil, nil] )
+
+		tm2 = PG::TypeMapByClass.new
+		tm2[Integer] = PG::TextEncoder::Integer.new name: 'INT2', oid: 21
+		tm2.default_type_map = tm1
+
+		res = @conn.exec_params( "SELECT $1, $2, $3::TEXT", ['1', 2, 3], 0, tm2 )
+
+		expect( res.ftype(0) ).to eq( 23 ) # tm1
+		expect( res.ftype(1) ).to eq( 21 ) # tm2
+		expect( res.getvalue(0,2) ).to eq( "3" ) # TypeMapAllStrings
+	end
+
+	#
+	# Decoding Examples
+	#
+
+	it "should raise an error when used for results" do
+		res = @conn.exec_params( "SELECT 1", [], 1 )
+		expect{ res.type_map = tm }.to raise_error(NotImplementedError, /not suitable to map result values/)
+	end
+
+	#
+	# Encoding Examples
+	#
+
+	it "should allow mixed type conversions" do
+		res = @conn.exec_params( "SELECT $1, $2, $3", [5, 1.23, :TestSymbol], 0, tm )
+		expect( res.values ).to eq([['5', '1.23', '[:TestSymbol]']])
+		expect( res.ftype(0) ).to eq(20)
+	end
+
+	it "should expire the cache after changes to the coders" do
+		res = @conn.exec_params( "SELECT $1", [5], 0, tm )
+		expect( res.ftype(0) ).to eq(20)
+
+		tm[Integer] = textenc_int
+
+		res = @conn.exec_params( "SELECT $1", [5], 0, tm )
+		expect( res.ftype(0) ).to eq(23)
+	end
+
+	it "should allow mixed type conversions with derived type map" do
+		res = @conn.exec_params( "SELECT $1, $2", [6, [7]], 0, derived_tm )
+		expect( res.values ).to eq([['6', '{7}']])
+		expect( res.ftype(0) ).to eq(23)
+		expect( res.ftype(1) ).to eq(1007)
+	end
+
+	it "should raise TypeError with derived type map" do
+		expect{
+			@conn.exec_params( "SELECT $1", [raise_class.new], 0, derived_tm )
+		}.to raise_error(TypeError, /invalid type Regexp/)
+	end
+
+	it "should raise error on invalid coder object" do
+		tm[TrueClass] = "dummy"
+		expect{
+			res = @conn.exec_params( "SELECT $1", [true], 0, tm )
+		}.to raise_error(NoMethodError, /undefined method.*call.*dummy/)
+	end
+end

data/spec/pg/type_map_by_column_spec.rb

@@ -46,6 +46,28 @@ describe PG::TypeMapByColumn do
 		expect( cm.oids ).to eq( [23, 25, 700, 123456, nil] )
 	end
 
+	it "should gracefully handle not initialized state" do
+		# PG::TypeMapByColumn is not initialized in allocate function, like other
+		# type maps, but in #initialize. So it might be not called by derived classes.
+
+		not_init = Class.new(PG::TypeMapByColumn) do
+			def initialize
+				# no super call
+			end
+		end.new
+
+		expect{ @conn.exec_params( "SELECT $1", [ 0 ], 0, not_init ) }.to raise_error(NotImplementedError)
+
+		res = @conn.exec( "SELECT 1" )
+		expect{ res.type_map = not_init }.to raise_error(NotImplementedError)
+
+		@conn.copy_data("COPY (SELECT 1) TO STDOUT") do
+			decoder = PG::TextDecoder::CopyRow.new(type_map: not_init)
+			expect{ @conn.get_copy_data(false, decoder) }.to raise_error(NotImplementedError)
+			@conn.get_copy_data
+		end
+	end
+
 
 	#
 	# Encoding Examples
@@ -95,6 +117,25 @@ describe PG::TypeMapByColumn do
 		}.to raise_error(ArgumentError, /mapped columns/)
 	end
 
+	it "should verify the default type map for query params as well" do
+		tm1 = PG::TypeMapByColumn.new([])
+		expect{
+			@conn.exec_params( "SELECT $1", [ 123 ], 0, PG::TypeMapByColumn.new([nil]).with_default_type_map(tm1) )
+		}.to raise_error(ArgumentError, /mapped columns/)
+	end
+
+	it "forwards query param conversions to the #default_type_map" do
+		tm1 = PG::TypeMapByClass.new
+		tm1[Integer] = PG::TextEncoder::Integer.new name: 'INT2', oid: 21
+
+		tm2 = PG::TypeMapByColumn.new( [textenc_int, nil, nil] ).with_default_type_map( tm1 )
+		res = @conn.exec_params( "SELECT $1, $2, $3::TEXT", [1, 2, :abc], 0, tm2 )
+
+		expect( res.ftype(0) ).to eq( 23 ) # tm2
+		expect( res.ftype(1) ).to eq( 21 ) # tm1
+		expect( res.getvalue(0,2) ).to eq( "abc" ) # TypeMapAllStrings
+	end
+
 	#
 	# Decoding Examples
 	#
@@ -122,6 +163,52 @@ describe PG::TypeMapByColumn do
 		expect{ res.type_map = PG::TypeMapByColumn.new([]) }.to raise_error(ArgumentError, /mapped columns/)
 	end
 
+	it "should verify the default type map for result values as well" do
+		res = @conn.exec( "SELECT 1" )
+		tm1 = PG::TypeMapByColumn.new([])
+		expect{
+			res.type_map = PG::TypeMapByColumn.new([nil]).with_default_type_map(tm1)
+		}.to raise_error(ArgumentError, /mapped columns/)
+	end
+
+	it "forwards result value conversions to a TypeMapByOid as #default_type_map" do
+		# One run with implicit built TypeMapByColumn and another with online lookup
+		[0, 10].each do |max_rows|
+			tm1 = PG::TypeMapByOid.new
+			tm1.add_coder PG::TextDecoder::Integer.new name: 'INT2', oid: 21
+			tm1.max_rows_for_online_lookup = max_rows
+
+			tm2 = PG::TypeMapByColumn.new( [textdec_int, nil, nil] ).with_default_type_map( tm1 )
+			res = @conn.exec( "SELECT '1'::INT4, '2'::INT2, '3'::INT8" ).map_types!( tm2 )
+
+			expect( res.getvalue(0,0) ).to eq( 1 ) # tm2
+			expect( res.getvalue(0,1) ).to eq( 2 ) # tm1
+			expect( res.getvalue(0,2) ).to eq( "3" ) # TypeMapAllStrings
+		end
+	end
+
+	it "forwards get_copy_data conversions to another TypeMapByColumn as #default_type_map" do
+		tm1 = PG::TypeMapByColumn.new( [textdec_int, nil, nil] )
+		tm2 = PG::TypeMapByColumn.new( [nil, textdec_int, nil] ).with_default_type_map( tm1 )
+		decoder = PG::TextDecoder::CopyRow.new(type_map: tm2)
+		@conn.copy_data("COPY (SELECT 1, 2, 3) TO STDOUT", decoder) do
+			expect( @conn.get_copy_data ).to eq( [1, 2, '3'] )
+			@conn.get_copy_data
+		end
+	end
+
+	it "will deny copy queries with different column count" do
+		[[2, 2], [2, 3], [3, 2]].each do |cols1, cols2|
+			tm1 = PG::TypeMapByColumn.new( [textdec_int, nil, nil][0, cols1] )
+			tm2 = PG::TypeMapByColumn.new( [nil, textdec_int, nil][0, cols2] ).with_default_type_map( tm1 )
+			decoder = PG::TextDecoder::CopyRow.new(type_map: tm2)
+			@conn.copy_data("COPY (SELECT 1, 2, 3) TO STDOUT", decoder) do
+				expect{ @conn.get_copy_data }.to raise_error(ArgumentError, /number of copy fields/)
+				@conn.get_copy_data
+			end
+		end
+	end
+
 	#
 	# Decoding Examples text format
 	#