pg 0.18.1 → 0.18.2

data/ext/pg_text_encoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_encoder.c - PG::TextEncoder module
- * $Id: pg_text_encoder.c,v 1a13e7eafeb7 2014/12/12 20:57:39 lars $
+ * $Id: pg_text_encoder.c,v b859963462b2 2015/03/13 17:39:35 lars $
  *
  */
 
@@ -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

@@ -1,6 +1,6 @@
 /*
  * pg_type_map_by_mri_type.c - PG::TypeMapByMriType class extension
- * $Id: pg_type_map_by_mri_type.c,v 27987dbd0b32 2014/11/07 20:55:52 lars $
+ * $Id: pg_type_map_by_mri_type.c,v 1269b8ad77b8 2015/02/06 16:38:23 lars $
  *
  * This type map can be used to select value encoders based on the MRI-internal
  * value type code.
@@ -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

@@ -1,6 +1,6 @@
 /*
  * pg_type_map_in_ruby.c - PG::TypeMapInRuby class extension
- * $Id: pg_type_map_in_ruby.c,v a38cf53a96f1 2014/12/13 21:59:57 lars $
+ * $Id: pg_type_map_in_ruby.c,v 3d89d3aae4fd 2015/01/05 16:19:41 kanis $
  *
  */
 
@@ -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

@@ -1,6 +1,6 @@
 /*
  * util.c - Utils for ruby-pg
- * $Id: util.c,v 117fb5c5eed7 2014/10/15 18:36:39 lars $
+ * $Id: util.c,v b859963462b2 2015/03/13 17:39:35 lars $
  *
  */
 
@@ -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 */

data/lib/pg.rb

@@ -24,10 +24,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.18.1'
+	VERSION = '0.18.2'
 
 	# VCS revision
-	REVISION = %q$Revision: ba5aff64b5cb $
+	REVISION = %q$Revision: 7d31b04e7913 $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end

data/lib/pg/connection.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'pg' unless defined?( PG )
+require 'uri'
 
 # The PostgreSQL connection class. The interface for this class is based on
 # {libpq}[http://www.postgresql.org/docs/9.2/interactive/libpq.html], the C
@@ -34,46 +35,55 @@ class PG::Connection
 	def self::parse_connect_args( *args )
 		return '' if args.empty?
 
-		# This will be swapped soon for code that makes options like those required for
-		# PQconnectdbParams()/PQconnectStartParams(). For now, stick to an options string for
-		# PQconnectdb()/PQconnectStart().
+		hash_arg = args.last.is_a?( Hash ) ? args.pop : {}
+		option_string = ''
+		options = {}
 
 		# Parameter 'fallback_application_name' was introduced in PostgreSQL 9.0
 		# together with PQescapeLiteral().
-		if PG::Connection.instance_methods.find{|m| m.to_sym == :escape_literal }
-			appname = $0.sub(/^(.{30}).{4,}(.{30})$/){ $1+"..."+$2 }
-			appname = PG::Connection.quote_connstr( appname )
-			connopts = ["fallback_application_name=#{appname}"]
-		else
-			connopts = []
+		if PG::Connection.instance_methods.find {|m| m.to_sym == :escape_literal }
+			options[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
 		end
 
-		# Handle an options hash first
-		if args.last.is_a?( Hash )
-			opthash = args.pop
-			opthash.each do |key, val|
-				connopts.push( "%s=%s" % [key, PG::Connection.quote_connstr(val)] )
+		if args.length == 1
+			case args.first
+			when URI, URI.regexp
+				uri = URI(args.first)
+				options.merge!( Hash[URI.decode_www_form( uri.query )] ) if uri.query
+			when /=/
+				# Option string style
+				option_string = args.first.to_s
+			else
+				# Positional parameters
+				options[CONNECT_ARGUMENT_ORDER.first.to_sym] = args.first
 			end
-		end
-
-		# Option string style
-		if args.length == 1 && args.first.to_s.index( '=' )
-			connopts.unshift( args.first )
-
-		# Append positional parameters
 		else
-			args.each_with_index do |val, i|
-				next unless val # Skip nil placeholders
+			max = CONNECT_ARGUMENT_ORDER.length
+			raise ArgumentError,
+				"Extra positional parameter %d: %p" % [ max + 1, args[max] ] if args.length > max
 
-				key = CONNECT_ARGUMENT_ORDER[ i ] or
-					raise ArgumentError, "Extra positional parameter %d: %p" % [ i+1, val ]
-				connopts.push( "%s=%s" % [key, PG::Connection.quote_connstr(val.to_s)] )
+			CONNECT_ARGUMENT_ORDER.zip( args ) do |(k,v)|
+				options[ k.to_sym ] = v if v
 			end
 		end
 
-		return connopts.join(' ')
+		options.merge!( hash_arg )
+
+		if uri
+			uri.host     = nil if options[:host]
+			uri.port     = nil if options[:port]
+			uri.user     = nil if options[:user]
+			uri.password = nil if options[:password]
+			uri.path     = '' if options[:dbname]
+			uri.query    = URI.encode_www_form( options )
+			return uri.to_s.sub( /^#{uri.scheme}:(?!\/\/)/, "#{uri.scheme}://" )
+		else
+			option_string += ' ' unless option_string.empty? && options.empty?
+			return option_string + options.map { |k,v| "#{k}=#{quote_connstr(v)}" }.join( ' ' )
+		end
 	end
 
+
 	#  call-seq:
 	#     conn.copy_data( sql ) {|sql_result| ... } -> PG::Result
 	#

data/lib/pg/text_decoder.rb

@@ -27,11 +27,11 @@ module PG
 		end
 
 		class TimestampWithTimeZone < SimpleDecoder
-			ISO_DATETIME_WITH_TIMEZONE = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?([-\+]\d\d)\z/
+			ISO_DATETIME_WITH_TIMEZONE = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?([-\+]\d\d):?(\d\d)?:?(\d\d)?\z/
 
 			def decode(string, tuple=nil, field=nil)
 				if string =~ ISO_DATETIME_WITH_TIMEZONE
-					Time.new $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, "#{$6}#{$7}".to_r, "#{$8}:00"
+					Time.new $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, "#{$6}#{$7}".to_r, "#{$8}:#{$9 || '00'}:#{$10 || '00'}"
 				else
 					string
 				end

data/spec/pg/connection_spec.rb

@@ -45,6 +45,14 @@ describe PG::Connection do
 		expect( optstring ).to match( /(^|\s)user='jrandom'/ )
 	end
 
+	it "can create a connection option string from an option string and a hash" do
+		optstring = described_class.parse_connect_args( 'dbname=original', :user => 'jrandom' )
+
+		expect( optstring ).to be_a( String )
+		expect( optstring ).to match( /(^|\s)dbname=original/ )
+		expect( optstring ).to match( /(^|\s)user='jrandom'/ )
+	end
+
 	it "escapes single quotes and backslashes in connection parameters" do
 		expect(
 			described_class.parse_connect_args( "DB 'browser' \\" )
@@ -52,18 +60,72 @@ describe PG::Connection do
 
 	end
 
+	let(:uri) { 'postgresql://user:pass@pgsql.example.com:222/db01?sslmode=require' }
+
+	it "can connect using a URI" do
+		string = described_class.parse_connect_args( uri )
+
+		expect( string ).to be_a( String )
+		expect( string ).to match( %r{^postgresql://user:pass@pgsql.example.com:222/db01\?} )
+		expect( string ).to match( %r{\?.*sslmode=require} )
+
+		string = described_class.parse_connect_args( URI.parse(uri) )
+
+		expect( string ).to be_a( String )
+		expect( string ).to match( %r{^postgresql://user:pass@pgsql.example.com:222/db01\?} )
+		expect( string ).to match( %r{\?.*sslmode=require} )
+	end
+
+	it "can create a connection URI from a URI and a hash" do
+		string = described_class.parse_connect_args( uri, :connect_timeout => 2 )
+
+		expect( string ).to be_a( String )
+		expect( string ).to match( %r{^postgresql://user:pass@pgsql.example.com:222/db01\?} )
+		expect( string ).to match( %r{\?.*sslmode=require} )
+		expect( string ).to match( %r{\?.*connect_timeout=2} )
+
+		string = described_class.parse_connect_args( uri,
+			:user => 'a',
+			:password => 'b',
+			:host => 'localhost',
+			:port => 555,
+			:dbname => 'x' )
+
+		expect( string ).to be_a( String )
+		expect( string ).to match( %r{^postgresql://\?} )
+		expect( string ).to match( %r{\?.*user=a} )
+		expect( string ).to match( %r{\?.*password=b} )
+		expect( string ).to match( %r{\?.*host=localhost} )
+		expect( string ).to match( %r{\?.*port=555} )
+		expect( string ).to match( %r{\?.*dbname=x} )
+	end
+
+	it "can create a connection URI with a non-standard domain socket directory" do
+		string = described_class.parse_connect_args( 'postgresql://%2Fvar%2Flib%2Fpostgresql/dbname' )
+
+		expect( string ).to be_a( String )
+		expect( string ).to match( %r{^postgresql://%2Fvar%2Flib%2Fpostgresql/dbname} )
+
+		string = described_class.
+			parse_connect_args( 'postgresql:///dbname', :host => '/var/lib/postgresql' )
+
+		expect( string ).to be_a( String )
+		expect( string ).to match( %r{^postgresql:///dbname\?} )
+		expect( string ).to match( %r{\?.*host=%2Fvar%2Flib%2Fpostgresql} )
+	end
+
 	it "connects with defaults if no connection parameters are given" do
 		expect( described_class.parse_connect_args ).to eq( '' )
 	end
 
 	it "connects successfully with connection string" do
-		tmpconn = described_class.connect(@conninfo)
+		tmpconn = described_class.connect( @conninfo )
 		expect( tmpconn.status ).to eq( PG::CONNECTION_OK )
 		tmpconn.finish
 	end
 
 	it "connects using 7 arguments converted to strings" do
-		tmpconn = described_class.connect('localhost', @port, nil, nil, :test, nil, nil)
+		tmpconn = described_class.connect( 'localhost', @port, nil, nil, :test, nil, nil )
 		expect( tmpconn.status ).to eq( PG::CONNECTION_OK )
 		tmpconn.finish
 	end
@@ -89,8 +151,13 @@ describe PG::Connection do
 
 	it "raises an exception when connecting with an invalid number of arguments" do
 		expect {
-			described_class.connect( 1, 2, 3, 4, 5, 6, 7, 'extra' )
-		}.to raise_error( ArgumentError, /extra positional parameter/i )
+			described_class.connect( 1, 2, 3, 4, 5, 6, 7, 'the-extra-arg' )
+		}.to raise_error do |error|
+			expect( error ).to be_an( ArgumentError )
+			expect( error.message ).to match( /extra positional parameter/i )
+			expect( error.message ).to match( /8/ )
+			expect( error.message ).to match( /the-extra-arg/ )
+		end
 	end
 
 	it "can connect asynchronously", :socket_io do
@@ -162,8 +229,6 @@ describe PG::Connection do
 		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( "" )
@@ -1128,9 +1193,20 @@ describe PG::Connection do
 				expect( escaped.encoding ).to eq( Encoding::ISO8859_1 )
 				expect( escaped ).to eq( "\"string to\"" )
 			end
+		end
 
+		it "can quote bigger strings with quote_ident" do
+			original = "'01234567\"" * 100
+			escaped = described_class.quote_ident( original + "\0afterzero" )
+			expect( escaped ).to eq( "\"" + original.gsub("\"", "\"\"") + "\"" )
 		end
 
+		it "can quote Arrays with quote_ident" do
+			original = "'01234567\""
+			escaped = described_class.quote_ident( [original]*3 )
+			expected = ["\"" + original.gsub("\"", "\"\"") + "\""] * 3
+			expect( escaped ).to eq( expected.join(".") )
+		end
 
 		describe "Ruby 1.9.x default_internal encoding" do