pg 0.21.0 → 1.2.3

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,19 +1,68 @@
-#!/usr/bin/env rspec
+# -*- rspec -*-
 # encoding: utf-8
 
 require_relative '../helpers'
 
 require 'pg'
+require 'objspace'
 
 
 describe PG::Result do
 
+	describe :field_name_type do
+		let!(:res) { @conn.exec('SELECT 1 AS a, 2 AS "B"') }
+
+		it "uses string field names per default" do
+			expect(res.field_name_type).to eq(:string)
+		end
+
+		it "can set string field names" do
+			res.field_name_type = :string
+			expect(res.field_name_type).to eq(:string)
+		end
+
+		it "can set symbol field names" do
+			res.field_name_type = :symbol
+			expect(res.field_name_type).to eq(:symbol)
+		end
+
+		it "can set static_symbol field names" do
+			res.field_name_type = :static_symbol
+			expect(res.field_name_type).to eq(:static_symbol)
+		end
+
+		it "can't set symbol field names after #fields" do
+			res.fields
+			expect{ res.field_name_type = :symbol }.to raise_error(ArgumentError, /already materialized/)
+			expect(res.field_name_type).to eq(:string)
+		end
+
+		it "can't set invalid values" do
+			expect{ res.field_name_type = :sym }.to raise_error(ArgumentError, /invalid argument :sym/)
+			expect{ res.field_name_type = "symbol" }.to raise_error(ArgumentError, /invalid argument "symbol"/)
+		end
+	end
+
 	it "acts as an array of hashes" do
 		res = @conn.exec("SELECT 1 AS a, 2 AS b")
 		expect( res[0]['a'] ).to eq( '1' )
 		expect( res[0]['b'] ).to eq( '2' )
 	end
 
+	it "acts as an array of hashes with symbols" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		res.field_name_type = :symbol
+		expect( res[0][:a] ).to eq( '1' )
+		expect( res[0][:b] ).to eq( '2' )
+	end
+
+	it "acts as an array of hashes with static_symbols" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		res.field_name_type = :static_symbol
+		expect( res[0][:a] ).to eq( '1' )
+		expect( res[0][:b] ).to eq( '2' )
+	end
+
 	it "yields a row as an array" do
 		res = @conn.exec("SELECT 1 AS a, 2 AS b")
 		list = []
@@ -25,7 +74,6 @@ describe PG::Result 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
@@ -34,13 +82,20 @@ describe PG::Result 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
+	it "yields a row as an Enumerator of hashs with symbols" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		res.field_name_type = :symbol
+		expect( res.each.to_a ).to eq [{:a=>'1', :b=>'2'}]
+	end
+
+	context "result streaming in single row mode" do
+		let!(:textdec_int){ PG::TextDecoder::Integer.new name: 'INT4', oid: 23 }
+
+		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 +111,32 @@ 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 Hash with symbols and typemap" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result.field_names_as(:symbol)
+			res.type_map = PG::TypeMapByColumn.new [textdec_int]
+			expect(
+				res.stream_each.to_a
+			).to eq(
+				[{:a=>2}, {:a=>3}, {:a=>4}]
+			)
+			expect( @conn.get_result ).to be_nil
+		end
+
+		it "keeps last result on error while iterating stream_each" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result
+			expect do
+				res.stream_each_row do
+					raise ZeroDivisionError
+				end
+			end.to raise_error(ZeroDivisionError)
+			expect( res.values ).to eq([["2"]])
+		end
+
+		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 +152,64 @@ describe PG::Result do
 			expect( @conn.get_result ).to be_nil
 		end
 
+		it "keeps last result on error while iterating stream_each_row" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result
+			expect do
+				res.stream_each_row do
+					raise ZeroDivisionError
+				end
+			end.to raise_error(ZeroDivisionError)
+			expect( res.values ).to eq([["2"]])
+		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 "clears result on error while iterating stream_each_tuple" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result
+			expect do
+				res.stream_each_tuple do
+					raise ZeroDivisionError
+				end
+			end.to raise_error(ZeroDivisionError)
+			expect( res.cleared? ).to eq(true)
+		end
+
+		it "should reuse field names in stream_each_tuple" do
+			@conn.send_query( "SELECT generate_series(2,3) AS a" )
+			@conn.set_single_row_mode
+			tuple1, tuple2 = *@conn.get_result.stream_each_tuple.to_a
+			expect( tuple1.keys[0].object_id ).to eq(tuple2.keys[0].object_id)
+		end
+
+		it "can iterate over all rows as PG::Tuple with symbols and typemap" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result.field_names_as(:symbol)
+			res.type_map = PG::TypeMapByColumn.new [textdec_int]
+			tuples = res.stream_each_tuple.to_a
+			expect( tuples[0][0] ).to eq( 2 )
+			expect( tuples[1][:a] ).to eq( 3 )
+			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,7 +234,7 @@ 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
 
@@ -131,6 +269,17 @@ describe PG::Result do
 		).to match( /^parserOpenTable$|^RangeVarGetRelid$/ )
 	end
 
+	it "encapsulates PG_DIAG_SEVERITY_NONLOCALIZED error in a PG::Error object", :postgresql_96 do
+		result = nil
+		begin
+			@conn.exec( "SELECT * FROM nonexistant_table" )
+		rescue PG::Error => err
+			result = err.result
+		end
+
+		expect( result.error_field(PG::PG_DIAG_SEVERITY_NONLOCALIZED) ).to eq( 'ERROR' )
+	end
+
 	it "encapsulates database object names for integrity constraint violations", :postgresql_93 do
 		@conn.exec( "CREATE TABLE integrity (id SERIAL PRIMARY KEY)" )
 		exception = nil
@@ -151,17 +300,39 @@ describe PG::Result do
 	it "detects division by zero as SQLSTATE 22012" do
 		sqlstate = nil
 		begin
-			res = @conn.exec("SELECT 1/0")
+			@conn.exec("SELECT 1/0")
 		rescue PG::Error => e
 			sqlstate = e.result.result_error_field( PG::PG_DIAG_SQLSTATE ).to_i
 		end
 		expect( sqlstate ).to eq( 22012 )
 	end
 
+	it "provides the error message" do
+		@conn.send_query("SELECT xyz")
+		res = @conn.get_result; @conn.get_result
+		expect( res.error_message ).to match(/"xyz"/)
+		expect( res.result_error_message ).to match(/"xyz"/)
+	end
+
+	it "provides a verbose error message", :postgresql_96 do
+		@conn.send_query("SELECT xyz")
+		res = @conn.get_result; @conn.get_result
+		# PQERRORS_TERSE should give a single line result
+		expect( res.verbose_error_message(PG::PQERRORS_TERSE, PG::PQSHOW_CONTEXT_ALWAYS) ).to match(/\A.*\n\z/)
+		# PQERRORS_VERBOSE should give a multi line result
+		expect( res.result_verbose_error_message(PG::PQERRORS_VERBOSE, PG::PQSHOW_CONTEXT_NEVER) ).to match(/\n.*\n/)
+	end
+
+	it "provides a verbose error message with SQLSTATE", :postgresql_12 do
+		@conn.send_query("SELECT xyz")
+		res = @conn.get_result; @conn.get_result
+		expect( res.verbose_error_message(PG::PQERRORS_SQLSTATE, PG::PQSHOW_CONTEXT_NEVER) ).to match(/42703/)
+	end
+
 	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 +344,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 +354,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 +365,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
 
@@ -242,6 +413,32 @@ describe PG::Result do
 		expect( res.values ).to eq( [ ["bar"], ["bar2"] ] )
 	end
 
+	it "can retrieve field names" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		expect(res.fields).to eq(["a", "B"])
+	end
+
+	it "can retrieve field names as symbols" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		res.field_name_type = :symbol
+		expect(res.fields).to eq([:a, :B])
+	end
+
+	it "can retrieve single field names" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		expect(res.fname(0)).to eq("a")
+		expect(res.fname(1)).to eq("B")
+		expect{res.fname(2)}.to raise_error(ArgumentError)
+	end
+
+	it "can retrieve single field names as symbol" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		res.field_name_type = :symbol
+		expect(res.fname(0)).to eq(:a)
+		expect(res.fname(1)).to eq(:B)
+		expect{res.fname(2)}.to raise_error(ArgumentError)
+	end
+
 	# PQfmod
 	it "can return the type modifier for a result column" do
 		@conn.exec( 'CREATE TABLE fmodtest ( foo varchar(33) )' )
@@ -339,8 +536,27 @@ describe PG::Result do
 		res = @conn.exec( "SELECT 1 AS x, 'a' AS y UNION ALL SELECT 2, 'b'" )
 		expect( res.field_values('x') ).to eq( ['1', '2'] )
 		expect( res.field_values('y') ).to eq( ['a', 'b'] )
+		expect( res.field_values(:x) ).to eq( ['1', '2'] )
 		expect{ res.field_values('') }.to raise_error(IndexError)
-		expect{ res.field_values(:x) }.to raise_error(TypeError)
+		expect{ res.field_values(0) }.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
@@ -386,7 +602,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|
@@ -410,6 +626,13 @@ describe PG::Result do
 		expect( r.inspect ).to match(/cleared/)
 	end
 
+	it "should give account about memory usage" do
+		r = @conn.exec "select 1"
+		expect( ObjectSpace.memsize_of(r) ).to be > 1000
+		r.clear
+		expect( ObjectSpace.memsize_of(r) ).to be < 100
+	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 }
@@ -436,6 +659,8 @@ 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.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,333 @@
+# -*- 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!(:result2x2sym) { @conn.exec( "VALUES(1, 'a'), (2, 'b')" ).field_names_as(:symbol) }
+	let!(:result2x3cast) do
+		@conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" )
+			.map_types!(typemap)
+	end
+	let!(:result2x3symcast) do
+		@conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" )
+			.map_types!(typemap)
+			.field_names_as(:symbol)
+	end
+	let!(:tuple0) { result2x2.tuple(0) }
+	let!(:tuple0sym) { result2x2sym.tuple(0) }
+	let!(:tuple1) { result2x2.tuple(1) }
+	let!(:tuple1sym) { result2x2sym.tuple(1) }
+	let!(:tuple2) { result2x3cast.tuple(0) }
+	let!(:tuple2sym) { result2x3symcast.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[:b] ).to be_nil
+			expect( tuple0["x"] ).to be_nil
+		end
+
+		it "supports hash like access with symbols" do
+			expect( tuple0sym[:column1] ).to eq( "1" )
+			expect( tuple0sym[:column2] ).to eq( "a" )
+			expect( tuple2sym[:a] ).to eq( 1 )
+			expect( tuple2sym[:b] ).to eq( "3" )
+			expect( tuple2sym["b"] ).to be_nil
+			expect( tuple0sym[: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 as an enumerator with symbols" do
+			expect( tuple0sym.each ).to be_kind_of(Enumerator)
+			expect( tuple0sym.each.to_a ).to eq( [[:column1, "1"], [:column2, "a"]] )
+			expect( tuple2sym.each.to_a ).to eq( [[:a, 1], [:b, true], [:b, "3"]] )
+		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?(:column1) ).to eq( false )
+		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 key? as symbol" do
+		expect( tuple1sym.key?(:column1) ).to eq( true )
+		expect( tuple1sym.key?("column1") ).to eq( false )
+		expect( tuple1sym.key?(:other) ).to eq( false )
+		expect( tuple1sym.has_key?(:column1) ).to eq( true )
+		expect( tuple1sym.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
+
+	it "responds to keys as symbol" do
+		expect( tuple0sym.keys ).to eq( [:column1, :column2] )
+		expect( tuple2sym.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(:column1) ).to eq( nil )
+		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 "responds to index with symbol" do
+		expect( tuple0sym.index(:column1) ).to eq( 0 )
+		expect( tuple0sym.index("column1") ).to eq( nil )
+		expect( tuple0sym.index(:column2) ).to eq( 1 )
+		expect( tuple0sym.index(:x) ).to eq( nil )
+		expect( tuple2sym.index(:a) ).to eq( 0 )
+		expect( tuple2sym.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, tuple0sym, tuple2sym].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( tuple2sym.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