pg 0.15.1-x64-mingw32 → 0.16.0-x64-mingw32

data/ext/pg_errors.c

@@ -0,0 +1,89 @@
+/*
+ * pg_errors.c - Definition and lookup of error classes.
+ *
+ */
+
+#include "pg.h"
+
+VALUE rb_hErrors;
+VALUE rb_ePGerror;
+VALUE rb_eServerError;
+VALUE rb_eUnableToSend;
+VALUE rb_eConnectionBad;
+
+static VALUE
+define_error_class(const char *name, const char *baseclass_code)
+{
+	VALUE baseclass = rb_eServerError;
+	if(baseclass_code)
+	{
+		baseclass = rb_hash_aref( rb_hErrors, rb_str_new2(baseclass_code) );
+	}
+	return rb_define_class_under( rb_mPG, name, baseclass );
+}
+
+static void
+register_error_class(const char *code, VALUE klass)
+{
+	rb_hash_aset( rb_hErrors, rb_str_new2(code), klass );
+}
+
+/* Find a proper error class for the given SQLSTATE string
+ */
+VALUE
+lookup_error_class(const char *sqlstate)
+{
+	VALUE klass;
+
+	if(sqlstate)
+	{
+		/* Find the proper error class by the 5-characters SQLSTATE. */
+		klass = rb_hash_aref( rb_hErrors, rb_str_new2(sqlstate) );
+		if(NIL_P(klass))
+		{
+			/* The given SQLSTATE couldn't be found. This might happen, if
+			 * the server side uses a newer version than the client.
+			 * Try to find a error class by using the 2-characters SQLSTATE.
+			 */
+			klass = rb_hash_aref( rb_hErrors, rb_str_new(sqlstate, 2) );
+			if(NIL_P(klass))
+			{
+				/* Also the 2-characters SQLSTATE is unknown.
+				 * Use the generic server error instead.
+				 */
+				klass = rb_eServerError;
+			}
+		}
+	}
+	else
+	{
+		/* Unable to retrieve the PG_DIAG_SQLSTATE.
+		 * Use the generic error instead.
+		 */
+		klass = rb_eUnableToSend;
+	}
+
+	return klass;
+}
+
+void
+init_pg_errors()
+{
+	rb_hErrors = rb_hash_new();
+	rb_define_const( rb_mPG, "ERROR_CLASSES", rb_hErrors );
+
+	rb_ePGerror = rb_define_class_under( rb_mPG, "Error", rb_eStandardError );
+
+	/*************************
+	 *  PG::Error
+	 *************************/
+	rb_define_alias( rb_ePGerror, "error", "message" );
+	rb_define_attr( rb_ePGerror, "connection", 1, 0 );
+	rb_define_attr( rb_ePGerror, "result", 1, 0 );
+
+	rb_eServerError = rb_define_class_under( rb_mPG, "ServerError", rb_ePGerror );
+	rb_eUnableToSend = rb_define_class_under( rb_mPG, "UnableToSend", rb_ePGerror );
+	rb_eConnectionBad = rb_define_class_under( rb_mPG, "ConnectionBad", rb_ePGerror );
+
+	#include "errorcodes.def"
+}

data/ext/pg_result.c

@@ -44,13 +44,14 @@ pg_new_result(PGresult *result, VALUE rb_pgconn)
 VALUE
 pg_result_check( VALUE self )
 {
-	VALUE error, exception;
+	VALUE error, exception, klass;
 	VALUE rb_pgconn = rb_iv_get( self, "@connection" );
 	PGconn *conn = pg_get_pgconn(rb_pgconn);
 	PGresult *result;
 #ifdef M17N_SUPPORTED
 	rb_encoding *enc = pg_conn_enc_get( conn );
 #endif
+	char * sqlstate;
 
 	Data_Get_Struct(self, PGresult, result);
 
@@ -87,9 +88,12 @@ pg_result_check( VALUE self )
 #ifdef M17N_SUPPORTED
 	rb_enc_set_index( error, rb_enc_to_index(enc) );
 #endif
-	exception = rb_exc_new3( rb_ePGerror, error );
+
+	sqlstate = PQresultErrorField( result, PG_DIAG_SQLSTATE );
+	klass = lookup_error_class( sqlstate );
+	exception = rb_exc_new3( klass, error );
 	rb_iv_set( exception, "@connection", rb_pgconn );
-	rb_iv_set( exception, "@result", self );
+	rb_iv_set( exception, "@result", result ? self : Qnil );
 	rb_exc_raise( exception );
 
 	/* Not reached */
@@ -245,18 +249,18 @@ pgresult_error_message(VALUE self)
  *       conn.exec( "SELECT * FROM nonexistant_table" )
  *   rescue PG::Error => err
  *       p [
- *           result.error_field( PG::Result::PG_DIAG_SEVERITY ),
- *           result.error_field( PG::Result::PG_DIAG_SQLSTATE ),
- *           result.error_field( PG::Result::PG_DIAG_MESSAGE_PRIMARY ),
- *           result.error_field( PG::Result::PG_DIAG_MESSAGE_DETAIL ),
- *           result.error_field( PG::Result::PG_DIAG_MESSAGE_HINT ),
- *           result.error_field( PG::Result::PG_DIAG_STATEMENT_POSITION ),
- *           result.error_field( PG::Result::PG_DIAG_INTERNAL_POSITION ),
- *           result.error_field( PG::Result::PG_DIAG_INTERNAL_QUERY ),
- *           result.error_field( PG::Result::PG_DIAG_CONTEXT ),
- *           result.error_field( PG::Result::PG_DIAG_SOURCE_FILE ),
- *           result.error_field( PG::Result::PG_DIAG_SOURCE_LINE ),
- *           result.error_field( PG::Result::PG_DIAG_SOURCE_FUNCTION ),
+ *           err.result.error_field( PG::Result::PG_DIAG_SEVERITY ),
+ *           err.result.error_field( PG::Result::PG_DIAG_SQLSTATE ),
+ *           err.result.error_field( PG::Result::PG_DIAG_MESSAGE_PRIMARY ),
+ *           err.result.error_field( PG::Result::PG_DIAG_MESSAGE_DETAIL ),
+ *           err.result.error_field( PG::Result::PG_DIAG_MESSAGE_HINT ),
+ *           err.result.error_field( PG::Result::PG_DIAG_STATEMENT_POSITION ),
+ *           err.result.error_field( PG::Result::PG_DIAG_INTERNAL_POSITION ),
+ *           err.result.error_field( PG::Result::PG_DIAG_INTERNAL_QUERY ),
+ *           err.result.error_field( PG::Result::PG_DIAG_CONTEXT ),
+ *           err.result.error_field( PG::Result::PG_DIAG_SOURCE_FILE ),
+ *           err.result.error_field( PG::Result::PG_DIAG_SOURCE_LINE ),
+ *           err.result.error_field( PG::Result::PG_DIAG_SOURCE_FUNCTION ),
  *       ]
  *   end
  *
@@ -510,6 +514,31 @@ pgresult_fsize(VALUE self, VALUE index)
 	return INT2NUM(PQfsize(result, i));
 }
 
+
+static VALUE
+pgresult_value(VALUE self, PGresult *result, int tuple_num, int field_num)
+{
+    VALUE val;
+    if ( PQgetisnull(result, tuple_num, field_num) ) {
+        return Qnil;
+    }
+    else {
+        val = rb_tainted_str_new( PQgetvalue(result, tuple_num, field_num ),
+                                  PQgetlength(result, tuple_num, field_num) );
+
+#ifdef M17N_SUPPORTED
+        /* associate client encoding for text format only */
+        if ( 0 == PQfformat(result, field_num) ) {
+            ASSOCIATE_INDEX( val, self );
+        } else {
+            rb_enc_associate( val, rb_ascii8bit_encoding() );
+        }
+#endif
+
+        return val;
+    }
+}
+
 /*
  * call-seq:
  *    res.getvalue( tup_num, field_num )
@@ -520,7 +549,6 @@ pgresult_fsize(VALUE self, VALUE index)
 static VALUE
 pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
 {
-	VALUE val;
 	PGresult *result;
 	int i = NUM2INT(tup_num);
 	int j = NUM2INT(field_num);
@@ -532,21 +560,7 @@ pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
 	if(j < 0 || j >= PQnfields(result)) {
 		rb_raise(rb_eArgError,"invalid field number %d", j);
 	}
-	if(PQgetisnull(result, i, j))
-		return Qnil;
-	val = rb_tainted_str_new(PQgetvalue(result, i, j),
-				PQgetlength(result, i, j));
-
-#ifdef M17N_SUPPORTED
-	/* associate client encoding for text format only */
-	if ( 0 == PQfformat(result, j) ) {
-		ASSOCIATE_INDEX( val, self );
-	} else {
-		rb_enc_associate( val, rb_ascii8bit_encoding() );
-	}
-#endif
-
-	return val;
+	return pgresult_value(self, result, i, j);
 }
 
 /*
@@ -696,7 +710,7 @@ pgresult_aref(VALUE self, VALUE index)
 	PGresult *result = pgresult_get(self);
 	int tuple_num = NUM2INT(index);
 	int field_num;
-	VALUE fname,val;
+	VALUE fname;
 	VALUE tuple;
 
 	if ( tuple_num < 0 || tuple_num >= PQntuples(result) )
@@ -706,24 +720,7 @@ pgresult_aref(VALUE self, VALUE index)
 	for ( field_num = 0; field_num < PQnfields(result); field_num++ ) {
 		fname = rb_tainted_str_new2( PQfname(result,field_num) );
 		ASSOCIATE_INDEX(fname, self);
-		if ( PQgetisnull(result, tuple_num, field_num) ) {
-			rb_hash_aset( tuple, fname, Qnil );
-		}
-		else {
-			val = rb_tainted_str_new( PQgetvalue(result, tuple_num, field_num ),
-			                          PQgetlength(result, tuple_num, field_num) );
-
-#ifdef M17N_SUPPORTED
-			/* associate client encoding for text format only */
-			if ( 0 == PQfformat(result, field_num) ) {
-				ASSOCIATE_INDEX( val, self );
-			} else {
-				rb_enc_associate( val, rb_ascii8bit_encoding() );
-			}
-#endif
-
-			rb_hash_aset( tuple, fname, val );
-		}
+		rb_hash_aset( tuple, fname, pgresult_value(self, result, tuple_num, field_num) );
 	}
 	return tuple;
 }
@@ -748,23 +745,7 @@ pgresult_each_row(VALUE self)
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
-			if ( PQgetisnull(result, row, field) ) {
-				rb_ary_store( new_row, field, Qnil );
-			}
-			else {
-				VALUE val = rb_tainted_str_new( PQgetvalue(result, row, field),
-				                                PQgetlength(result, row, field) );
-
-#ifdef M17N_SUPPORTED
-				/* associate client encoding for text format only */
-				if ( 0 == PQfformat(result, field) ) {
-					ASSOCIATE_INDEX( val, self );
-				} else {
-					rb_enc_associate( val, rb_ascii8bit_encoding() );
-				}
-#endif
-				rb_ary_store( new_row, field, val );
-			}
+		    rb_ary_store( new_row, field, pgresult_value(self, result, row, field) );
 		}
 		rb_yield( new_row );
 	}

data/lib/pg.rb

@@ -19,7 +19,7 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.15.1'
+	VERSION = '0.16.0'
 
 	# VCS revision
 	REVISION = %q$Revision$

data/spec/lib/helpers.rb

@@ -247,6 +247,13 @@ module PG::TestingHelpers
 			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
+	end
 end
 
 
@@ -270,9 +277,11 @@ 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 )
+		config.filter_run_excluding( :postgresql_91, :postgresql_92, :postgresql_93 )
 	elsif PG.library_version < 90200
-		config.filter_run_excluding( :postgresql_92 )
+		config.filter_run_excluding( :postgresql_92, :postgresql_93 )
+	elsif PG.library_version < 90300
+		config.filter_run_excluding( :postgresql_93 )
 	end
 end
 

data/spec/pg/connection_spec.rb

@@ -177,6 +177,11 @@ describe PG::Connection do
 		conn.should be_finished()
 	end
 
+	it "raises proper error when sending fails" do
+		conn = described_class.connect_start( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
+		expect{ conn.exec 'SELECT 1' }.to raise_error(PG::UnableToSend, /no connection/)
+	end
+
 	it "doesn't leave stale server connections after finish" do
 		described_class.connect(@conninfo).finish
 		sleep 0.5
@@ -257,6 +262,18 @@ describe PG::Connection do
 		error.should == true
 	end
 
+	it "can stop a thread that runs a blocking query" do
+		start = Time.now
+		t = Thread.new do
+			@conn.async_exec( 'select pg_sleep(10)' )
+		end
+		sleep 0.1
+
+		t.kill
+		t.join
+		(Time.now - start).should < 10
+	end
+
 	it "automatically rolls back a transaction started with Connection#transaction if an exception " +
 	   "is raised" do
 		# abort the per-example transaction so we can test our own
@@ -276,6 +293,16 @@ describe PG::Connection do
 		res.ntuples.should == 0
 	end
 
+	it "returns the block result from Connection#transaction" do
+		# abort the per-example transaction so we can test our own
+		@conn.exec( 'ROLLBACK' )
+
+		res = @conn.transaction do
+			"transaction result"
+		end
+		res.should == "transaction result"
+	end
+
 	it "not read past the end of a large object" do
 		@conn.transaction do
 			oid = @conn.lo_create( 0 )
@@ -400,6 +427,21 @@ describe PG::Connection do
 		@conn.exec( 'UNLISTEN woo' )
 	end
 
+	it "can receive notices while waiting for NOTIFY without exceeding the timeout", :postgresql_90 do
+		notices = []
+		@conn.set_notice_processor do |msg|
+			notices << [msg, Time.now]
+		end
+		st = Time.now
+		@conn.send_query "SELECT pg_sleep(0.5); do $$ BEGIN RAISE NOTICE 'woohoo'; END; $$ LANGUAGE plpgsql;"
+		@conn.wait_for_notify( 1 ).should be_nil
+		notices.first.should_not be_nil
+		et = Time.now
+		(et - notices.first[1]).should >= 0.4
+		(et - st).should >= 0.9
+		(et - st).should < 1.4
+	end
+
 	it "yields the result if block is given to exec" do
 		rval = @conn.exec( "select 1234::int as a union select 5678::int as a" ) do |result|
 			values = []
@@ -543,7 +585,7 @@ describe PG::Connection do
 		conn = PG.connect( @conninfo )
 
 		conn.finish
-		expect { conn.finish }.to raise_error( PG::Error, /connection is closed/i )
+		expect { conn.finish }.to raise_error( PG::ConnectionBad, /connection is closed/i )
 	end
 
 	it "closes the IO fetched from #socket_io when the connection is closed", :without_transaction, :socket_io do
@@ -551,7 +593,7 @@ describe PG::Connection do
 		io = conn.socket_io
 		conn.finish
 		io.should be_closed()
-		expect { conn.socket_io }.to raise_error( PG::Error, /connection is closed/i )
+		expect { conn.socket_io }.to raise_error( PG::ConnectionBad, /connection is closed/i )
 	end
 
 	it "closes the IO fetched from #socket_io when the connection is reset", :without_transaction, :socket_io do
@@ -563,6 +605,16 @@ describe PG::Connection do
 		conn.finish
 	end
 
+	it "block should raise ConnectionBad for a closed connection" do
+		serv = TCPServer.new( '127.0.0.1', 54320 )
+		conn = described_class.connect_start( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
+		while [PG::CONNECTION_STARTED, PG::CONNECTION_MADE].include?(conn.connect_poll)
+			sleep 0.1
+		end
+		serv.close
+		expect{ conn.block }.to raise_error(PG::ConnectionBad, /server closed the connection unexpectedly/)
+		expect{ conn.block }.to raise_error(PG::ConnectionBad, /can't get socket descriptor/)
+	end
 
 	context "under PostgreSQL 9", :postgresql_90 do
 
@@ -571,14 +623,16 @@ describe PG::Connection do
 		end
 
 		it "sets the fallback_application_name on new connections" do
-			PG::Connection.parse_connect_args( 'dbname=test' ).should include( $0 )
+			conn_string = PG::Connection.parse_connect_args( 'dbname=test' )
+			connection_string_should_contain_application_name(conn_string, $0)
 		end
 
 		it "sets a shortened fallback_application_name on new connections" do
 			old_0 = $0
 			begin
 				$0 = "/this/is/a/very/long/path/with/many/directories/to/our/beloved/ruby"
-				PG::Connection.parse_connect_args( 'dbname=test' ).should match(/\/this\/is\/a.*\.\.\..*\/beloved\/ruby/)
+				conn_string = PG::Connection.parse_connect_args( 'dbname=test' )
+				connection_string_should_contain_application_name(conn_string, $0)
 			ensure
 				$0 = old_0
 			end
@@ -874,17 +928,53 @@ describe PG::Connection do
 			end
 
 			it "uses the client encoding for escaped string" do
-				original = "string to escape".force_encoding( "euc-jp" )
+				original = "string to\0 escape".force_encoding( "iso8859-1" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = @conn.escape( original )
 				escaped.encoding.should == Encoding::EUC_JP
+				escaped.should == "string to"
 			end
 
-			it "escapes string as literal", :postgresql_90 do
-				original = "string to\0 escape"
+			it "uses the client encoding for escaped literal", :postgresql_90 do
+				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				@conn.set_client_encoding( "euc_jp" )
 				escaped  = @conn.escape_literal( original )
+				escaped.encoding.should == Encoding::EUC_JP
 				escaped.should == "'string to'"
 			end
+
+			it "uses the client encoding for escaped identifier", :postgresql_90 do
+				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				@conn.set_client_encoding( "euc_jp" )
+				escaped  = @conn.escape_identifier( original )
+				escaped.encoding.should == Encoding::EUC_JP
+				escaped.should == "\"string to\""
+			end
+
+			it "uses the client encoding for quote_ident" do
+				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				@conn.set_client_encoding( "euc_jp" )
+				escaped  = @conn.quote_ident( original )
+				escaped.encoding.should == Encoding::EUC_JP
+				escaped.should == "\"string to\""
+			end
+
+			it "uses the previous string encoding for escaped string" do
+				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				@conn.set_client_encoding( "euc_jp" )
+				escaped  = described_class.escape( original )
+				escaped.encoding.should == Encoding::ISO8859_1
+				escaped.should == "string to"
+			end
+
+			it "uses the previous string encoding for quote_ident" do
+				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				@conn.set_client_encoding( "euc_jp" )
+				escaped  = described_class.quote_ident( original )
+				escaped.encoding.should == Encoding::ISO8859_1
+				escaped.should == "\"string to\""
+			end
+
 		end
 
 
@@ -1010,7 +1100,7 @@ describe PG::Connection do
 	end
 
 	context "OS thread support", :ruby_19 do
-		it "described_class#exec shouldn't block a second thread" do
+		it "Connection#exec shouldn't block a second thread" do
 			t = Thread.new do
 				@conn.exec( "select pg_sleep(1)" )
 			end
@@ -1019,5 +1109,20 @@ describe PG::Connection do
 			t.should be_alive()
 			t.join
 		end
+
+		it "Connection.new shouldn't block a second thread" do
+			serv = nil
+			t = Thread.new do
+				serv = TCPServer.new( '127.0.0.1', 54320 )
+				expect {
+					described_class.new( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
+				}.to raise_error(PG::ConnectionBad, /server closed the connection unexpectedly/)
+			end
+
+			sleep 0.5
+			t.should be_alive()
+			serv.close
+			t.join
+		end
 	end
 end