pg 0.19.0 → 1.1.0

data/spec/pg/connection_sync_spec.rb

@@ -0,0 +1,41 @@
+# -*- rspec -*-
+#encoding: utf-8
+
+require_relative '../helpers'
+
+context "running with sync_* methods" do
+	before :each do
+		PG::Connection.async_api = false
+	end
+
+	after :each do
+		PG::Connection.async_api = true
+	end
+
+	fname = File.expand_path("../connection_spec.rb", __FILE__)
+	eval File.read(fname, encoding: __ENCODING__), binding, fname
+
+
+	it "enables/disables async/sync methods by #async_api" do
+		[true, false].each do |async|
+			PG::Connection.async_api = async
+
+			start = Time.now
+			t = Thread.new do
+				@conn.exec( 'select pg_sleep(1)' )
+			end
+			sleep 0.1
+
+			t.kill
+			t.join
+			dt = Time.now - start
+
+			if async
+				expect( dt ).to be < 1.0
+			else
+				expect( dt ).to be >= 1.0
+			end
+		end
+	end
+
+end

data/spec/pg/result_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'
@@ -39,8 +39,8 @@ describe PG::Result do
 		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
+	context "result streaming in single row mode" do
+		it "can iterate over all rows as Hash" 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(
@@ -56,7 +56,7 @@ describe PG::Result do
 			expect( @conn.get_result ).to be_nil
 		end
 
-		it "can iterate over all rows in single row mode" do
+		it "can iterate over all rows as Array" 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(
@@ -72,6 +72,22 @@ describe PG::Result do
 			expect( @conn.get_result ).to be_nil
 		end
 
+		it "can iterate over all rows as PG::Tuple" 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
+			tuples = @conn.get_result.stream_each_tuple.to_a
+			expect( tuples[0][0] ).to eq( "2" )
+			expect( tuples[1]["a"] ).to eq( "3" )
+			expect( tuples.size ).to eq( 3 )
+
+			tuples = @conn.get_result.enum_for(:stream_each_tuple).to_a
+			expect( tuples[-1][-1] ).to eq( "6" )
+			expect( tuples[-2]["b"] ).to eq( "1" )
+			expect( tuples.size ).to eq( 2 )
+
+			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{
@@ -96,15 +112,15 @@ describe PG::Result do
 	end
 
 	it "inserts nil AS NULL and return NULL as nil" do
-		res = @conn.exec("SELECT $1::int AS n", [nil])
+		res = @conn.exec_params("SELECT $1::int AS n", [nil])
 		expect( res[0]['n'] ).to be_nil()
 	end
 
-	it "encapsulates errors in a PGError object" do
+	it "encapsulates errors in a PG::Error object" do
 		exception = nil
 		begin
 			@conn.exec( "SELECT * FROM nonexistant_table" )
-		rescue PGError => err
+		rescue PG::Error => err
 			exception = err
 		end
 
@@ -136,7 +152,7 @@ describe PG::Result do
 		exception = nil
 		begin
 			@conn.exec( "INSERT INTO integrity VALUES (NULL)" )
-		rescue PGError => err
+		rescue PG::Error => err
 			exception = err
 		end
 		result = exception.result
@@ -152,7 +168,7 @@ describe PG::Result do
 		sqlstate = nil
 		begin
 			res = @conn.exec("SELECT 1/0")
-		rescue PGError => e
+		rescue PG::Error => e
 			sqlstate = e.result.result_error_field( PG::PG_DIAG_SQLSTATE ).to_i
 		end
 		expect( sqlstate ).to eq( 22012 )
@@ -161,7 +177,7 @@ describe PG::Result do
 	it "returns the same bytes in binary format that are sent in binary format" do
 		binary_file = File.join(Dir.pwd, 'spec/data', 'random_binary_data')
 		bytes = File.open(binary_file, 'rb').read
-		res = @conn.exec('VALUES ($1::bytea)',
+		res = @conn.exec_params('VALUES ($1::bytea)',
 			[ { :value => bytes, :format => 1 } ], 1)
 		expect( res[0]['column1'] ).to eq( bytes )
 		expect( res.getvalue(0,0) ).to eq( bytes )
@@ -173,7 +189,7 @@ describe PG::Result do
 		binary_file = File.join(Dir.pwd, 'spec/data', 'random_binary_data')
 		bytes = File.open(binary_file, 'rb').read
 		@conn.exec("SET standard_conforming_strings=on")
-		res = @conn.exec("VALUES ('#{PG::Connection.escape_bytea(bytes)}'::bytea)", [], 1)
+		res = @conn.exec_params("VALUES ('#{PG::Connection.escape_bytea(bytes)}'::bytea)", [], 1)
 		expect( res[0]['column1'] ).to eq( bytes )
 		expect( res.getvalue(0,0) ).to eq( bytes )
 		expect( res.values[0][0] ).to eq( bytes )
@@ -183,7 +199,7 @@ describe PG::Result do
 	it "returns the same bytes in text format that are sent in binary format" do
 		binary_file = File.join(Dir.pwd, 'spec/data', 'random_binary_data')
 		bytes = File.open(binary_file, 'rb').read
-		res = @conn.exec('VALUES ($1::bytea)',
+		res = @conn.exec_params('VALUES ($1::bytea)',
 			[ { :value => bytes, :format => 1 } ])
 		expect( PG::Connection.unescape_bytea(res[0]['column1']) ).to eq( bytes )
 	end
@@ -194,21 +210,21 @@ describe PG::Result do
 
 		out_bytes = nil
 		@conn.exec("SET standard_conforming_strings=on")
-		res = @conn.exec("VALUES ('#{PG::Connection.escape_bytea(in_bytes)}'::bytea)", [], 0)
+		res = @conn.exec_params("VALUES ('#{PG::Connection.escape_bytea(in_bytes)}'::bytea)", [], 0)
 		out_bytes = PG::Connection.unescape_bytea(res[0]['column1'])
 		expect( out_bytes ).to eq( in_bytes )
 	end
 
-	it "returns the parameter type of the specified prepared statement parameter", :postgresql_92 do
+	it "returns the parameter type of the specified prepared statement parameter" do
 		query = 'SELECT * FROM pg_stat_activity WHERE user = $1::name AND query = $2::text'
 		@conn.prepare( 'queryfinder', query )
 		res = @conn.describe_prepared( 'queryfinder' )
 
 		expect(
-			@conn.exec( 'SELECT format_type($1, -1)', [res.paramtype(0)] ).getvalue( 0, 0 )
+			@conn.exec_params( 'SELECT format_type($1, -1)', [res.paramtype(0)] ).getvalue( 0, 0 )
 		).to eq( 'name' )
 		expect(
-			@conn.exec( 'SELECT format_type($1, -1)', [res.paramtype(1)] ).getvalue( 0, 0 )
+			@conn.exec_params( 'SELECT format_type($1, -1)', [res.paramtype(1)] ).getvalue( 0, 0 )
 		).to eq( 'text' )
 	end
 
@@ -343,6 +359,24 @@ describe PG::Result do
 		expect{ res.field_values(:x) }.to raise_error(TypeError)
 	end
 
+	it "can return the values of a single tuple" do
+		res = @conn.exec( "SELECT 1 AS x, 'a' AS y UNION ALL SELECT 2, 'b'" )
+		expect( res.tuple_values(0) ).to eq( ['1', 'a'] )
+		expect( res.tuple_values(1) ).to eq( ['2', 'b'] )
+		expect{ res.tuple_values(2) }.to raise_error(IndexError)
+		expect{ res.tuple_values(-1) }.to raise_error(IndexError)
+		expect{ res.tuple_values("x") }.to raise_error(TypeError)
+	end
+
+	it "can return the values of a single vary lazy tuple" do
+		res = @conn.exec( "VALUES(1),(2)" )
+		expect( res.tuple(0) ).to be_kind_of( PG::Tuple )
+		expect( res.tuple(1) ).to be_kind_of( PG::Tuple )
+		expect{ res.tuple(2) }.to raise_error(IndexError)
+		expect{ res.tuple(-1) }.to raise_error(IndexError)
+		expect{ res.tuple("x") }.to raise_error(TypeError)
+	end
+
 	it "raises a proper exception for a nonexistant table" do
 		expect {
 			@conn.exec( "SELECT * FROM nonexistant_table" )
@@ -386,7 +420,7 @@ describe PG::Result do
 	end
 
 	it "the raised result is nil in case of a connection error" do
-		c = PGconn.connect_start( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
+		c = PG::Connection.connect_start( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
 		expect {
 			c.exec "select 1"
 		}.to raise_error {|error|
@@ -403,6 +437,13 @@ describe PG::Result do
 		expect( r.cleared? ).to eq(true)
 	end
 
+	it "can be inspected before and after clear" do
+		r = @conn.exec "select 1"
+		expect( r.inspect ).to match(/status=PGRES_TUPLES_OK/)
+		r.clear
+		expect( r.inspect ).to match(/cleared/)
+	end
+
 	context 'result value conversions with TypeMapByColumn' do
 		let!(:textdec_int){ PG::TextDecoder::Integer.new name: 'INT4', oid: 23 }
 		let!(:textdec_float){ PG::TextDecoder::Float.new name: 'FLOAT4', oid: 700 }
@@ -429,6 +470,7 @@ describe PG::Result do
 			expect( res.enum_for(:each).to_a ).to eq( [{'f' => 123}] )
 			expect( res.column_values(0) ).to eq( [123] )
 			expect( res.field_values('f') ).to eq( [123] )
+			expect( res.tuple_values(0) ).to eq( [123] )
 		end
 
 		it "should be usable for several querys" do

data/spec/pg/tuple_spec.rb

@@ -0,0 +1,280 @@
+# -*- rspec -*-
+# encoding: utf-8
+
+require_relative '../helpers'
+require 'pg'
+require 'objspace'
+
+describe PG::Tuple do
+	let!(:typemap) { PG::BasicTypeMapForResults.new(@conn) }
+	let!(:result2x2) { @conn.exec( "VALUES(1, 'a'), (2, 'b')" ) }
+	let!(:result2x3cast) { @conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" ).map_types!(typemap) }
+	let!(:tuple0) { result2x2.tuple(0) }
+	let!(:tuple1) { result2x2.tuple(1) }
+	let!(:tuple2) { result2x3cast.tuple(0) }
+	let!(:tuple3) { str = Marshal.dump(result2x3cast.tuple(1)); Marshal.load(str) }
+	let!(:tuple_empty) { PG::Tuple.new }
+
+	describe "[]" do
+		it "returns nil for invalid keys" do
+			expect( tuple0["x"] ).to be_nil
+			expect( tuple0[0.5] ).to be_nil
+			expect( tuple0[2] ).to be_nil
+			expect( tuple0[-3] ).to be_nil
+			expect( tuple2[-4] ).to be_nil
+			expect{ tuple_empty[0] }.to raise_error(TypeError)
+		end
+
+		it "supports array like access" do
+			expect( tuple0[0] ).to eq( "1" )
+			expect( tuple0[1] ).to eq( "a" )
+			expect( tuple1[0] ).to eq( "2" )
+			expect( tuple1[1] ).to eq( "b" )
+			expect( tuple2[0] ).to eq( 1 )
+			expect( tuple2[1] ).to eq( true )
+			expect( tuple2[2] ).to eq( "3" )
+			expect( tuple3[0] ).to eq( 2 )
+			expect( tuple3[1] ).to eq( false )
+			expect( tuple3[2] ).to eq( "4" )
+		end
+
+		it "supports negative indices" do
+			expect( tuple0[-2] ).to eq( "1" )
+			expect( tuple0[-1] ).to eq( "a" )
+			expect( tuple2[-3] ).to eq( 1 )
+			expect( tuple2[-2] ).to eq( true )
+			expect( tuple2[-1] ).to eq( "3" )
+		end
+
+		it "supports hash like access" do
+			expect( tuple0["column1"] ).to eq( "1" )
+			expect( tuple0["column2"] ).to eq( "a" )
+			expect( tuple2["a"] ).to eq( 1 )
+			expect( tuple2["b"] ).to eq( "3" )
+			expect( tuple0["x"] ).to be_nil
+		end
+
+		it "casts lazy and caches result" do
+			a = []
+			deco = Class.new(PG::SimpleDecoder) do
+				define_method(:decode) do |*args|
+					a << args
+					args.last
+				end
+			end.new
+
+			result2x2.map_types!(PG::TypeMapByColumn.new([deco, deco]))
+			t = result2x2.tuple(1)
+
+			# cast and cache at first call to [0]
+			a.clear
+			expect( t[0] ).to eq( 0 )
+			expect( a ).to eq([["2", 1, 0]])
+
+			# use cache at second call to [0]
+			a.clear
+			expect( t[0] ).to eq( 0 )
+			expect( a ).to eq([])
+
+			# cast and cache at first call to [1]
+			a.clear
+			expect( t[1] ).to eq( 1 )
+			expect( a ).to eq([["b", 1, 1]])
+		end
+	end
+
+	describe "fetch" do
+		it "raises proper errors for invalid keys" do
+			expect{ tuple0.fetch("x") }.to raise_error(KeyError)
+			expect{ tuple0.fetch(0.5) }.to raise_error(KeyError)
+			expect{ tuple0.fetch(2) }.to raise_error(IndexError)
+			expect{ tuple0.fetch(-3) }.to raise_error(IndexError)
+			expect{ tuple0.fetch(-3) }.to raise_error(IndexError)
+			expect{ tuple2.fetch(-4) }.to raise_error(IndexError)
+			expect{ tuple_empty[0] }.to raise_error(TypeError)
+		end
+
+		it "supports array like access" do
+			expect( tuple0.fetch(0) ).to eq( "1" )
+			expect( tuple0.fetch(1) ).to eq( "a" )
+			expect( tuple2.fetch(0) ).to eq( 1 )
+			expect( tuple2.fetch(1) ).to eq( true )
+			expect( tuple2.fetch(2) ).to eq( "3" )
+		end
+
+		it "supports default value for indices" do
+			expect( tuple0.fetch(2, 42) ).to eq( 42 )
+			expect( tuple0.fetch(2){43} ).to eq( 43 )
+		end
+
+		it "supports negative indices" do
+			expect( tuple0.fetch(-2) ).to eq( "1" )
+			expect( tuple0.fetch(-1) ).to eq( "a" )
+			expect( tuple2.fetch(-3) ).to eq( 1 )
+			expect( tuple2.fetch(-2) ).to eq( true )
+			expect( tuple2.fetch(-1) ).to eq( "3" )
+		end
+
+		it "supports hash like access" do
+			expect( tuple0.fetch("column1") ).to eq( "1" )
+			expect( tuple0.fetch("column2") ).to eq( "a" )
+			expect( tuple2.fetch("a") ).to eq( 1 )
+			expect( tuple2.fetch("b") ).to eq( "3" )
+		end
+
+		it "supports default value for name keys" do
+			expect( tuple0.fetch("x", "defa") ).to eq("defa")
+			expect( tuple0.fetch("x"){"defa"} ).to eq("defa")
+		end
+	end
+
+	describe "each" do
+		it "can be used as an enumerator" do
+			expect( tuple0.each ).to be_kind_of(Enumerator)
+			expect( tuple0.each.to_a ).to eq( [["column1", "1"], ["column2", "a"]] )
+			expect( tuple1.each.to_a ).to eq( [["column1", "2"], ["column2", "b"]] )
+			expect( tuple2.each.to_a ).to eq( [["a", 1], ["b", true], ["b", "3"]] )
+			expect( tuple3.each.to_a ).to eq( [["a", 2], ["b", false], ["b", "4"]] )
+			expect{ tuple_empty.each }.to raise_error(TypeError)
+		end
+
+		it "can be used with block" do
+			a = []
+			tuple0.each do |*v|
+				a << v
+			end
+			expect( a ).to eq( [["column1", "1"], ["column2", "a"]] )
+		end
+	end
+
+	describe "each_value" do
+		it "can be used as an enumerator" do
+			expect( tuple0.each_value ).to be_kind_of(Enumerator)
+			expect( tuple0.each_value.to_a ).to eq( ["1", "a"] )
+			expect( tuple1.each_value.to_a ).to eq( ["2", "b"] )
+			expect( tuple2.each_value.to_a ).to eq( [1, true, "3"] )
+			expect( tuple3.each_value.to_a ).to eq( [2, false, "4"] )
+			expect{ tuple_empty.each_value }.to raise_error(TypeError)
+		end
+
+		it "can be used with block" do
+			a = []
+			tuple0.each_value do |v|
+				a << v
+			end
+			expect( a ).to eq( ["1", "a"] )
+		end
+	end
+
+	it "responds to values" do
+		expect( tuple0.values ).to eq( ["1", "a"] )
+		expect( tuple3.values ).to eq( [2, false, "4"] )
+		expect{ tuple_empty.values }.to raise_error(TypeError)
+	end
+
+	it "responds to key?" do
+		expect( tuple1.key?("column1") ).to eq( true )
+		expect( tuple1.key?("other") ).to eq( false )
+		expect( tuple1.has_key?("column1") ).to eq( true )
+		expect( tuple1.has_key?("other") ).to eq( false )
+	end
+
+	it "responds to keys" do
+		expect( tuple0.keys ).to eq( ["column1", "column2"] )
+		expect( tuple2.keys ).to eq( ["a", "b", "b"] )
+	end
+
+	describe "each_key" do
+		it "can be used as an enumerator" do
+			expect( tuple0.each_key ).to be_kind_of(Enumerator)
+			expect( tuple0.each_key.to_a ).to eq( ["column1", "column2"] )
+			expect( tuple2.each_key.to_a ).to eq( ["a", "b", "b"] )
+		end
+
+		it "can be used with block" do
+			a = []
+			tuple0.each_key do |v|
+				a << v
+			end
+			expect( a ).to eq( ["column1", "column2"] )
+		end
+	end
+
+	it "responds to length" do
+		expect( tuple0.length ).to eq( 2 )
+		expect( tuple0.size ).to eq( 2 )
+		expect( tuple2.size ).to eq( 3 )
+	end
+
+	it "responds to index" do
+		expect( tuple0.index("column1") ).to eq( 0 )
+		expect( tuple0.index("column2") ).to eq( 1 )
+		expect( tuple0.index("x") ).to eq( nil )
+		expect( tuple2.index("a") ).to eq( 0 )
+		expect( tuple2.index("b") ).to eq( 2 )
+	end
+
+	it "can be used as Enumerable" do
+		expect( tuple0.to_a ).to eq( [["column1", "1"], ["column2", "a"]] )
+		expect( tuple1.to_a ).to eq( [["column1", "2"], ["column2", "b"]] )
+		expect( tuple2.to_a ).to eq( [["a", 1], ["b", true], ["b", "3"]] )
+		expect( tuple3.to_a ).to eq( [["a", 2], ["b", false], ["b", "4"]] )
+	end
+
+	it "can be marshaled" do
+		[tuple0, tuple1, tuple2, tuple3].each do |t1|
+			str = Marshal.dump(t1)
+			t2 = Marshal.load(str)
+
+			expect( t2 ).to be_kind_of(t1.class)
+			expect( t2 ).not_to equal(t1)
+			expect( t2.to_a ).to eq(t1.to_a)
+		end
+	end
+
+	it "passes instance variables when marshaled" do
+		t1 = tuple0
+		t1.instance_variable_set("@a", 4711)
+		str = Marshal.dump(t1)
+		t2 = Marshal.load(str)
+
+		expect( t2.instance_variable_get("@a") ).to eq( 4711 )
+	end
+
+	it "can't be marshaled when empty" do
+		expect{ Marshal.dump(tuple_empty) }.to raise_error(TypeError)
+	end
+
+	it "should give account about memory usage" do
+		expect( ObjectSpace.memsize_of(tuple0) ).to be > 40
+		expect( ObjectSpace.memsize_of(tuple_empty) ).to be > 0
+	end
+
+	it "should override #inspect" do
+		expect( tuple1.inspect ).to eq('#<PG::Tuple column1: "2", column2: "b">')
+		expect( tuple2.inspect ).to eq('#<PG::Tuple a: 1, b: true, b: "3">')
+		expect{ tuple_empty.inspect }.to raise_error(TypeError)
+	end
+
+	context "with cleared result" do
+		it "should raise an error when non-materialized fields are used" do
+			r = result2x2
+			t = r.tuple(0)
+			t[0] # materialize first field only
+			r.clear
+
+			# second column should fail
+			expect{ t[1] }.to raise_error(PG::Error)
+			expect{ t.fetch(1) }.to raise_error(PG::Error)
+			expect{ t.fetch("column2") }.to raise_error(PG::Error)
+
+			# first column should succeed
+			expect( t[0] ).to eq( "1" )
+			expect( t.fetch(0) ).to eq( "1" )
+			expect( t.fetch("column1") ).to eq( "1" )
+
+			# should fail due to the second column
+			expect{ t.values }.to raise_error(PG::Error)
+		end
+	end
+end

data/spec/pg/type_map_by_class_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'
@@ -59,7 +59,7 @@ describe PG::TypeMapByClass do
 	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( tm[Range] ).to be_nil
 		expect( derived_tm[raise_class] ).to be_kind_of(Proc)
 		expect( derived_tm[Array] ).to eq(:array_type_map_for)
 	end

data/spec/pg/type_map_by_column_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'

data/spec/pg/type_map_by_mri_type_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'

data/spec/pg/type_map_by_oid_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'

data/spec/pg/type_map_in_ruby_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'

data/spec/pg/type_map_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'