pg 0.18.1-x86-mingw32 → 0.18.2-x86-mingw32

data/History.rdoc

@@ -1,3 +1,18 @@
+== v0.18.2 [2015-05-14] Michael Granger <ged@FaerieMUD.org>
+
+Enhancements:
+
+- Allow URI connection string (thanks to Chris Bandy)
+
+Bugfixes:
+
+- Speedups and fixes for PG::TextDecoder::Identifier and quoting behavior
+- Revert addition of PG::Connection#hostaddr [#202].
+- Fix decoding of fractional timezones and timestamps [#203]
+- Fixes for non-C99 compilers
+- Avoid possible symbol name clash when linking againt static libpq.
+
+
 == v0.18.1 [2015-01-05] Michael Granger <ged@FaerieMUD.org>
 
 Correct the minimum compatible Ruby version to 1.9.3. #199
@@ -19,6 +34,7 @@ Enhancements:
 - Add Enumerator variant to PG::Result#each and #each_row.
 - Add PG::Connection#conninfo and #hostaddr.
 - Add PG.init_openssl and PG.init_ssl methods.
+- Add PG::Result.inspect
 - Force zero termination for all text strings that are given to libpq.
   It raises an ArgumentError if the string contains a null byte.
 - Update Windows cross build to PostgreSQL 9.3.

data/README.rdoc

@@ -130,7 +130,7 @@ Lars Kanis <lars@greiz-reinsdorf.de>.
 
 == Copying
 
-Copyright (c) 1997-2013 by the authors.
+Copyright (c) 1997-2015 by the authors.
 
 * Jeff Davis <ruby-pg@j-davis.com>
 * Guy Decoux (ts) <decoux@moulon.inra.fr>

data/Rakefile.cross

@@ -217,6 +217,11 @@ class CrossLibrary < OpenStruct
 
 		# make libpq.dll
 		task postgresql_lib => [ postgresql_global_makefile ] do |t|
+			# Work around missing dependency to libcommon in PostgreSQL-9.4.0
+			chdir( static_postgresql_srcdir + "common" ) do
+				sh 'make', "-j#{NUM_CPUS}"
+			end
+
 			chdir( postgresql_lib.dirname ) do
 				sh 'make',
 					"-j#{NUM_CPUS}",

data/ext/extconf.rb

@@ -73,7 +73,6 @@ have_func 'PQlibVersion'
 have_func 'PQping'
 have_func 'PQsetSingleRowMode'
 have_func 'PQconninfo'
-have_func 'PQhostaddr'
 
 have_func 'rb_encdb_alias'
 have_func 'rb_enc_alias'
@@ -95,6 +94,10 @@ $defs.push( "-DHAVE_ST_NOTIFY_EXTRA" ) if
 have_header 'unistd.h'
 have_header 'ruby/st.h' or have_header 'st.h' or abort "pg currently requires the ruby/st.h header"
 
+checking_for "C99 variable length arrays" do
+	$defs.push( "-DHAVE_VARIABLE_LENGTH_ARRAYS" ) if try_compile('void test_vla(int l){ int vla[l]; }')
+end
+
 create_header()
 create_makefile( "pg_ext" )
 

data/ext/pg.c

@@ -15,7 +15,7 @@
  * See Contributors.rdoc for the many additional fine people that have contributed
  * to this library over the years.
  *
- * Copyright (c) 1997-2012 by the authors.
+ * Copyright (c) 1997-2015 by the authors.
  *
  * You may redistribute this software under the same terms as Ruby itself; see
  * http://www.ruby-lang.org/en/LICENSE.txt or the LICENSE file in the source
@@ -252,7 +252,7 @@ pg_get_rb_encoding_as_pg_encoding( rb_encoding *enc )
  *   char *current_out, *end_capa;
  *   PG_RB_STR_NEW( string, current_out, end_capa );
  *   while( data_is_going_to_be_processed ){
- *     PG_RB_STR_ENSURE_CAPA( string, 2 current_out, end_capa );
+ *     PG_RB_STR_ENSURE_CAPA( string, 2, current_out, end_capa );
  *     *current_out++ = databyte1;
  *     *current_out++ = databyte2;
  *   }

data/ext/pg.h

@@ -133,6 +133,15 @@
 typedef long suseconds_t;
 #endif
 
+#if defined(HAVE_VARIABLE_LENGTH_ARRAYS)
+	#define PG_VARIABLE_LENGTH_ARRAY(type, name, len, maxlen) type name[(len)];
+#else
+	#define PG_VARIABLE_LENGTH_ARRAY(type, name, len, maxlen) \
+		type name[(maxlen)] = {(len)>(maxlen) ? (rb_raise(rb_eArgError, "Number of " #name " (%d) exceeds allowed maximum of " #maxlen, (len) ), (type)1) : (type)0};
+
+	#define PG_MAX_COLUMNS 4000
+#endif
+
 /* The data behind each PG::Connection object */
 typedef struct {
 	PGconn *pgconn;
@@ -313,6 +322,7 @@ VALUE lookup_error_class                               _(( const char * ));
 VALUE pg_bin_dec_bytea                                 _(( t_pg_coder*, char *, int, int, int, int ));
 VALUE pg_text_dec_string                               _(( t_pg_coder*, char *, int, int, int, int ));
 int pg_coder_enc_to_s                                  _(( t_pg_coder*, VALUE, char *, VALUE *));
+int pg_text_enc_identifier                             _(( t_pg_coder*, VALUE, char *, VALUE *));
 t_pg_coder_enc_func pg_coder_enc_func                  _(( t_pg_coder* ));
 t_pg_coder_dec_func pg_coder_dec_func                  _(( t_pg_coder*, int ));
 void pg_define_coder                                   _(( const char *, void *, VALUE, VALUE ));

data/ext/pg_connection.c

@@ -627,22 +627,6 @@ pgconn_host(VALUE self)
 	return rb_tainted_str_new2(host);
 }
 
-#ifdef HAVE_PQHOSTADDR
-/*
- * call-seq:
- *    conn.hostaddr()
- *
- * Returns the server numeric IP address of the connection.
- */
-static VALUE
-pgconn_hostaddr(VALUE self)
-{
-	char *hostaddr = PQhostaddr(pg_get_pgconn(self));
-	if (!hostaddr) return Qnil;
-	return rb_tainted_str_new2(hostaddr);
-}
-#endif
-
 /*
  * call-seq:
  *    conn.port()
@@ -3013,7 +2997,9 @@ pgconn_transaction(VALUE self)
 /*
  * call-seq:
  *    PG::Connection.quote_ident( str ) -> String
+ *    PG::Connection.quote_ident( array ) -> String
  *    conn.quote_ident( str ) -> String
+ *    conn.quote_ident( array ) -> String
  *
  * Returns a string that is safe for inclusion in a SQL query as an
  * identifier. Note: this is not a quote function for values, but for
@@ -3030,31 +3016,20 @@ pgconn_transaction(VALUE self)
  * Similarly, this function also protects against special characters,
  * and other things that might allow SQL injection if the identifier
  * comes from an untrusted source.
+ *
+ * If the parameter is an Array, then all it's values are separately quoted
+ * and then joined by a "." character. This can be used for identifiers in
+ * the form "schema"."table"."column" .
+ *
+ * This method is functional identical to the encoder PG::TextEncoder::Identifier .
+ *
  */
 static VALUE
 pgconn_s_quote_ident(VALUE self, VALUE in_str)
 {
 	VALUE ret;
-	char *str = StringValuePtr(in_str);
-	/* result size at most NAMEDATALEN*2 plus surrounding
-	 * double-quotes. */
-	char buffer[NAMEDATALEN*2+2];
-	unsigned int i=0,j=0;
-	unsigned int str_len = RSTRING_LENINT(in_str);
-
-	if(str_len >= NAMEDATALEN) {
-		rb_raise(rb_eArgError,
-			"Input string is longer than NAMEDATALEN-1 (%d)",
-			NAMEDATALEN-1);
-	}
-	buffer[j++] = '"';
-	for(i = 0; i < str_len && str[i]; i++) {
-		if(str[i] == '"')
-			buffer[j++] = '"';
-		buffer[j++] = str[i];
-	}
-	buffer[j++] = '"';
-	ret = rb_str_new(buffer,j);
+	pg_text_enc_identifier(NULL, in_str, NULL, &ret);
+
 	OBJ_INFECT(ret, in_str);
 	PG_ENCODING_SET_NOCHECK(ret, ENCODING_GET( rb_obj_class(self) == rb_cPGconn ? self : in_str ));
 
@@ -3835,9 +3810,6 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "user", pgconn_user, 0);
 	rb_define_method(rb_cPGconn, "pass", pgconn_pass, 0);
 	rb_define_method(rb_cPGconn, "host", pgconn_host, 0);
-#ifdef HAVE_PQHOSTADDR
-	rb_define_method(rb_cPGconn, "hostaddr", pgconn_hostaddr, 0);
-#endif
 	rb_define_method(rb_cPGconn, "port", pgconn_port, 0);
 	rb_define_method(rb_cPGconn, "tty", pgconn_tty, 0);
 #ifdef HAVE_PQCONNINFO

data/ext/pg_result.c

@@ -863,7 +863,7 @@ pgresult_each_row(VALUE self)
 	num_fields = PQnfields(this->pgresult);
 
 	for ( row = 0; row < num_rows; row++ ) {
-		VALUE row_values[num_fields];
+		PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, num_fields, PG_MAX_COLUMNS)
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
@@ -892,7 +892,7 @@ pgresult_values(VALUE self)
 	VALUE results = rb_ary_new2( num_rows );
 
 	for ( row = 0; row < num_rows; row++ ) {
-		VALUE row_values[num_fields];
+		PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, num_fields, PG_MAX_COLUMNS)
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
@@ -1176,7 +1176,7 @@ pgresult_stream_each_row(VALUE self)
 		}
 
 		for ( row = 0; row < ntuples; row++ ) {
-			VALUE row_values[nfields];
+			PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, nfields, PG_MAX_COLUMNS)
 			int field;
 
 			/* populate the row */

data/ext/pg_text_decoder.c

@@ -293,7 +293,7 @@ pg_text_dec_array(t_pg_coder *conv, char *val, int len, int tuple, int field, in
 }
 
 /*
- * Document-class: PG::TextDecoder::Identifier < PG::CompositeDecoder
+ * Document-class: PG::TextDecoder::Identifier < PG::SimpleDecoder
  *
  * This is the decoder class for PostgreSQL identifiers.
  *
@@ -305,16 +305,13 @@ pg_text_dec_array(t_pg_coder *conv, char *val, int len, int tuple, int field, in
 static VALUE
 pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
 {
-	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
-	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, 0);
-
 	/* Return value: array */
 	VALUE array;
 	VALUE elem;
 	int word_index = 0;
 	int index;
 	/* Use a buffer of the same length, as that will be the worst case */
-	char word[len + 1];
+	PG_VARIABLE_LENGTH_ARRAY(char, word, len + 1, NAMEDATALEN)
 
 	/* The current character in the input string. */
 	char c;
@@ -331,7 +328,7 @@ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int fiel
 		if(c == '.' && openQuote < 2 ) {
 			word[word_index] = 0;
 
-			elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
+			elem = pg_text_dec_string(conv, word, word_index, tuple, field, enc_idx);
 			rb_ary_push(array, elem);
 
 			openQuote = 0;
@@ -353,7 +350,7 @@ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int fiel
 	}
 
 	word[word_index] = 0;
-	elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
+	elem = pg_text_dec_string(conv, word, word_index, tuple, field, enc_idx);
 	rb_ary_push(array, elem);
 
 	return array;
@@ -412,11 +409,11 @@ init_pg_text_decoder()
 	pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Bytea", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Bytea", pg_text_dec_bytea, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Identifier", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Identifier", pg_text_dec_identifier, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Array", rb_cPG_CompositeDecoder ); */
 	pg_define_coder( "Array", pg_text_dec_array, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
-	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Identifier", rb_cPG_CompositeDecoder ); */
-	pg_define_coder( "Identifier", pg_text_dec_identifier, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "FromBase64", rb_cPG_CompositeDecoder ); */
 	pg_define_coder( "FromBase64", pg_text_dec_from_base64, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
 }

data/ext/pg_text_encoder.c

@@ -299,7 +299,7 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 	/* count data plus backslashes; detect chars needing quotes */
 	if (strlen == 0)
 		needquote = 1;   /* force quotes for empty string */
-	else if (strlen == 4 && pg_strncasecmp(p_in, "NULL", strlen) == 0)
+	else if (strlen == 4 && rbpg_strncasecmp(p_in, "NULL", strlen) == 0)
 		needquote = 1;   /* force quotes for literal NULL */
 	else
 		needquote = 0;
@@ -455,39 +455,34 @@ pg_text_enc_array(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 	}
 }
 
-static int
-quote_identifier_buffer( void *_this, char *p_in, int strlen, char *p_out ){
+static char *
+quote_identifier( VALUE value, VALUE out_string, char *current_out ){
+	char *p_in = RSTRING_PTR(value);
 	char *ptr1;
-	char *ptr2;
-	int backslashs = 0;
+	size_t strlen = RSTRING_LEN(value);
+	char *end_capa = current_out;
 
-	/* count required backlashs */
+	PG_RB_STR_ENSURE_CAPA( out_string, strlen + 2, current_out, end_capa );
+	*current_out++ = '"';
 	for(ptr1 = p_in; ptr1 != p_in + strlen; ptr1++) {
-		if (*ptr1 == '"'){
-			backslashs++;
+		char c = *ptr1;
+		if (c == '"'){
+			strlen++;
+			PG_RB_STR_ENSURE_CAPA( out_string, p_in - ptr1 + strlen + 1, current_out, end_capa );
+			*current_out++ = '"';
+		} else if (c == 0){
+			break;
 		}
+		*current_out++ = c;
 	}
+	PG_RB_STR_ENSURE_CAPA( out_string, 1, current_out, end_capa );
+	*current_out++ = '"';
 
-	ptr1 = p_in + strlen;
-	ptr2 = p_out + strlen + backslashs + 2;
-	/* Write end quote */
-	*--ptr2 = '"';
-
-	/* Then store the escaped string on the final position, walking
-		* right to left, until all backslashs are placed. */
-	while( ptr1 != p_in ) {
-		*--ptr2 = *--ptr1;
-		if(*ptr2 == '"'){
-			*--ptr2 = '"';
-		}
-	}
-	/* Write start quote */
-	*p_out = '"';
-	return strlen + backslashs + 2;
+	return current_out;
 }
 
 static char *
-pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE string, char *out)
+pg_text_enc_array_identifier(VALUE value, VALUE string, char *out)
 {
 	int i;
 	int nr_elems;
@@ -498,7 +493,7 @@ pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE stri
 	for( i=0; i<nr_elems; i++){
 		VALUE entry = rb_ary_entry(value, i);
 
-		out = quote_string(this->elem, entry, string, out, this->needs_quotation, quote_identifier_buffer, this);
+		out = quote_identifier(entry, string, out);
 		if( i < nr_elems-1 ){
 			out = pg_rb_str_ensure_capa( string, 1, out, NULL );
 			*out++ = '.';
@@ -508,27 +503,29 @@ pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE stri
 }
 
 /*
- * Document-class: PG::TextEncoder::Identifier < PG::CompositeEncoder
+ * Document-class: PG::TextEncoder::Identifier < PG::SimpleEncoder
  *
  * This is the encoder class for PostgreSQL identifiers.
  *
  * An Array value can be used for "schema.table.column" type identifiers:
  *   PG::TextEncoder::Identifier.new.encode(['schema', 'table', 'column'])
- *      => "schema"."table"."column"
+ *      => '"schema"."table"."column"'
  *
+ *  This encoder can also be used per PG::Connection#quote_ident .
  */
-static int
-pg_text_enc_identifier(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+int
+pg_text_enc_identifier(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
 {
-	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
-
-	*intermediate = rb_str_new(NULL, 0);
-	out = RSTRING_PTR(*intermediate);
-
+	UNUSED( this );
 	if( TYPE(value) == T_ARRAY){
-		out = pg_text_enc_array_identifier(this, value, *intermediate, out);
+		*intermediate = rb_str_new(NULL, 0);
+		out = RSTRING_PTR(*intermediate);
+		out = pg_text_enc_array_identifier(value, *intermediate, out);
 	} else {
-		out = quote_string(this->elem, value, *intermediate, out, this->needs_quotation, quote_identifier_buffer, this);
+		StringValue(value);
+		*intermediate = rb_str_new(NULL, RSTRING_LEN(value) + 2);
+		out = RSTRING_PTR(*intermediate);
+		out = quote_identifier(value, *intermediate, out);
 	}
 	rb_str_set_len( *intermediate, out - RSTRING_PTR(*intermediate) );
 	return -1;
@@ -651,11 +648,11 @@ init_pg_text_encoder()
 	pg_define_coder( "String", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Bytea", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "Bytea", pg_text_enc_bytea, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Identifier", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Identifier", pg_text_enc_identifier, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Array", rb_cPG_CompositeEncoder ); */
 	pg_define_coder( "Array", pg_text_enc_array, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
-	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Identifier", rb_cPG_CompositeEncoder ); */
-	pg_define_coder( "Identifier", pg_text_enc_identifier, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "QuotedLiteral", rb_cPG_CompositeEncoder ); */
 	pg_define_coder( "QuotedLiteral", pg_text_enc_quoted_literal, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "ToBase64", rb_cPG_CompositeEncoder ); */

data/ext/pg_type_map_by_mri_type.c

@@ -39,7 +39,7 @@ static VALUE rb_cTypeMapByMriType;
 typedef struct {
 	t_typemap typemap;
 	struct pg_tmbmt_converter {
-		FOR_EACH_MRI_TYPE( DECLARE_CODER );
+		FOR_EACH_MRI_TYPE( DECLARE_CODER )
 	} coders;
 } t_tmbmt;
 

data/ext/pg_type_map_in_ruby.c

@@ -212,12 +212,9 @@ pg_tmir_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format
 	rb_encoding *p_encoding = rb_enc_from_index(enc_idx);
 	VALUE enc = rb_enc_from_encoding(p_encoding);
 	/* field_str is reused in-place by pg_text_dec_copy_row(), so we need to make
-	 * a copy of the string buffer before used in ruby space.
-	 * This requires rb_str_new() instead of rb_str_dup() for Rubinius.
-	 */
-	VALUE field_str_copy = rb_str_new(RSTRING_PTR(field_str), RSTRING_LEN(field_str));
-	PG_ENCODING_SET_NOCHECK(field_str_copy, ENCODING_GET(field_str));
-	OBJ_INFECT(field_str_copy, field_str);
+	 * a copy of the string buffer for use in ruby space. */
+	VALUE field_str_copy = rb_str_dup(field_str);
+	rb_str_modify(field_str_copy);
 
 	return rb_funcall( this->self, s_id_typecast_copy_get, 4, field_str_copy, INT2NUM(fieldno), INT2NUM(format), enc );
 }

data/ext/util.c

@@ -124,7 +124,7 @@ base64_decode( char *out, char *in, unsigned int len)
  * At most n bytes will be examined from each string.
  */
 int
-pg_strncasecmp(const char *s1, const char *s2, size_t n)
+rbpg_strncasecmp(const char *s1, const char *s2, size_t n)
 {
 	while (n-- > 0)
 	{

data/ext/util.h

@@ -60,6 +60,6 @@
 void base64_encode( char *out, char *in, int len);
 int base64_decode( char *out, char *in, unsigned int len);
 
-int pg_strncasecmp(const char *s1, const char *s2, size_t n);
+int rbpg_strncasecmp(const char *s1, const char *s2, size_t n);
 
 #endif /* end __utils_h */