pg 0.18.1 → 0.19.0

data/ext/pg_type_map.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map.c,v c99d26015e3c 2014/12/12 20:58:25 lars $
+ * $Id: pg_type_map.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
  *
  */
 
@@ -54,12 +54,12 @@ pg_typemap_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno
 }
 
 const struct pg_typemap_funcs pg_typemap_funcs = {
-	.fit_to_result = pg_typemap_fit_to_result,
-	.fit_to_query = pg_typemap_fit_to_query,
-	.fit_to_copy_get = pg_typemap_fit_to_copy_get,
-	.typecast_result_value = pg_typemap_result_value,
-	.typecast_query_param = pg_typemap_typecast_query_param,
-	.typecast_copy_get = pg_typemap_typecast_copy_get
+	pg_typemap_fit_to_result,
+	pg_typemap_fit_to_query,
+	pg_typemap_fit_to_copy_get,
+	pg_typemap_result_value,
+	pg_typemap_typecast_query_param,
+	pg_typemap_typecast_copy_get
 };
 
 static VALUE

data/ext/pg_type_map_by_column.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map_by_column.c,v d369d31e8fe3 2014/10/22 08:47:29 lars $
+ * $Id: pg_type_map_by_column.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
  *
  */
 
@@ -162,12 +162,12 @@ pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, i
 }
 
 const struct pg_typemap_funcs pg_tmbc_funcs = {
-	.fit_to_result = pg_tmbc_fit_to_result,
-	.fit_to_query = pg_tmbc_fit_to_query,
-	.fit_to_copy_get = pg_tmbc_fit_to_copy_get,
-	.typecast_result_value = pg_tmbc_result_value,
-	.typecast_query_param = pg_tmbc_typecast_query_param,
-	.typecast_copy_get = pg_tmbc_typecast_copy_get
+	pg_tmbc_fit_to_result,
+	pg_tmbc_fit_to_query,
+	pg_tmbc_fit_to_copy_get,
+	pg_tmbc_result_value,
+	pg_tmbc_typecast_query_param,
+	pg_tmbc_typecast_copy_get
 };
 
 static void

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 5fb9170f6a7d 2015/06/29 11:15:12 kanis $
  *
  */
 
@@ -17,7 +17,7 @@ static const char base64_encode_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijk
 void
 base64_encode( char *out, char *in, int len)
 {
-	char *in_ptr = in + len;
+	unsigned char *in_ptr = (unsigned char *)in + len;
 	char *out_ptr = out + BASE64_ENCODED_SIZE(len);
 	int part_len = len % 3;
 
@@ -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

@@ -10,7 +10,7 @@ rescue LoadError
 
 		# Set the PATH environment variable, so that libpq.dll can be found.
 		old_path = ENV['PATH']
-		ENV['PATH'] = "#{File.expand_path("../#{RUBY_PLATFORM}", __FILE__)};#{old_path}"
+		ENV['PATH'] = "#{File.expand_path("..", __FILE__)};#{old_path}"
 		require "#{major_minor}/pg_ext"
 		ENV['PATH'] = old_path
 	else
@@ -24,10 +24,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.18.1'
+	VERSION = '0.19.0'
 
 	# VCS revision
-	REVISION = %q$Revision: ba5aff64b5cb $
+	REVISION = %q$Revision: 8beaa5d72670 $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end

data/lib/pg/basic_type_mapping.rb

@@ -25,9 +25,9 @@ module PG::BasicTypeRegistry
 
 			# populate the enum types
 			_enums, leaves = leaves.partition { |row| row['typinput'] == 'enum_in' }
-	# 		enums.each do |row|
-	# 			coder_map[row['oid'].to_i] = OID::Enum.new
-	# 		end
+			# enums.each do |row|
+			#	coder_map[row['oid'].to_i] = OID::Enum.new
+			# end
 
 			# populate the base types
 			leaves.find_all { |row| coders_by_name.key?(row['typname']) }.each do |row|
@@ -41,9 +41,9 @@ module PG::BasicTypeRegistry
 			_records_by_oid = result.group_by { |row| row['oid'] }
 
 			# populate composite types
-	# 		nodes.each do |row|
-	# 			add_oid row, records_by_oid, coder_map
-	# 		end
+			# nodes.each do |row|
+			#	add_oid row, records_by_oid, coder_map
+			# end
 
 			if arraycoder
 				# populate array types
@@ -62,11 +62,11 @@ module PG::BasicTypeRegistry
 			end
 
 			# populate range types
-	# 		ranges.find_all { |row| coder_map.key? row['rngsubtype'].to_i }.each do |row|
-	# 			subcoder = coder_map[row['rngsubtype'].to_i]
-	# 			range = OID::Range.new subcoder
-	# 			coder_map[row['oid'].to_i] = range
-	# 		end
+			# ranges.find_all { |row| coder_map.key? row['rngsubtype'].to_i }.each do |row|
+			#	subcoder = coder_map[row['rngsubtype'].to_i]
+			#	range = OID::Range.new subcoder
+			#	coder_map[row['oid'].to_i] = range
+			# end
 
 			@coders = coder_map.values
 			@coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }
@@ -154,46 +154,47 @@ module PG::BasicTypeRegistry
 	alias_type    0, 'int8', 'int2'
 	alias_type    0, 'oid',  'int2'
 
-# 	register_type 0, 'numeric', OID::Decimal.new
+	# register_type 0, 'numeric', OID::Decimal.new
 	register_type 0, 'text', PG::TextEncoder::String, PG::TextDecoder::String
 	alias_type 0, 'varchar', 'text'
 	alias_type 0, 'char', 'text'
 	alias_type 0, 'bpchar', 'text'
 	alias_type 0, 'xml', 'text'
 
-# 	# FIXME: why are we keeping these types as strings?
-# 	alias_type 'tsvector', 'text'
-# 	alias_type 'interval', 'text'
-# 	alias_type 'macaddr',  'text'
-# 	alias_type 'uuid',     'text'
-#
-# 	register_type 'money', OID::Money.new
+	# FIXME: why are we keeping these types as strings?
+	# alias_type 'tsvector', 'text'
+	# alias_type 'interval', 'text'
+	# alias_type 'macaddr',  'text'
+	# alias_type 'uuid',     'text'
+	#
+	# register_type 'money', OID::Money.new
 	# There is no PG::TextEncoder::Bytea, because it's simple and more efficient to send bytea-data
 	# in binary format, either with PG::BinaryEncoder::Bytea or in Hash param format.
 	register_type 0, 'bytea', nil, PG::TextDecoder::Bytea
 	register_type 0, 'bool', PG::TextEncoder::Boolean, PG::TextDecoder::Boolean
-# 	register_type 'bit', OID::Bit.new
-# 	register_type 'varbit', OID::Bit.new
-#
+	# register_type 'bit', OID::Bit.new
+	# register_type 'varbit', OID::Bit.new
+
 	register_type 0, 'float4', PG::TextEncoder::Float, PG::TextDecoder::Float
 	alias_type 0, 'float8', 'float4'
 
 	register_type 0, 'timestamp', PG::TextEncoder::TimestampWithoutTimeZone, PG::TextDecoder::TimestampWithoutTimeZone
 	register_type 0, 'timestamptz', PG::TextEncoder::TimestampWithTimeZone, PG::TextDecoder::TimestampWithTimeZone
 	register_type 0, 'date', PG::TextEncoder::Date, PG::TextDecoder::Date
-# 	register_type 'time', OID::Time.new
-#
-# 	register_type 'path', OID::Text.new
-# 	register_type 'point', OID::Point.new
-# 	register_type 'polygon', OID::Text.new
-# 	register_type 'circle', OID::Text.new
-# 	register_type 'hstore', OID::Hstore.new
-# 	register_type 'json', OID::Json.new
-# 	register_type 'citext', OID::Text.new
-# 	register_type 'ltree', OID::Text.new
-#
-# 	register_type 'cidr', OID::Cidr.new
-# 	alias_type 'inet', 'cidr'
+	# register_type 'time', OID::Time.new
+	#
+	# register_type 'path', OID::Text.new
+	# register_type 'point', OID::Point.new
+	# register_type 'polygon', OID::Text.new
+	# register_type 'circle', OID::Text.new
+	# register_type 'hstore', OID::Hstore.new
+	register_type 0, 'json', PG::TextEncoder::JSON, PG::TextDecoder::JSON
+	alias_type    0, 'jsonb',  'json'
+	# register_type 'citext', OID::Text.new
+	# register_type 'ltree', OID::Text.new
+	#
+	# register_type 'cidr', OID::Cidr.new
+	# alias_type 'inet', 'cidr'
 
 
 
@@ -226,8 +227,8 @@ end
 #
 # Example:
 #   conn = PG::Connection.new
-#   # Assign a default ruleset for type casts of input and output values.
-#   conn.type_mapping = PG::BasicTypeMapping.new(conn)
+#   # Assign a default ruleset for type casts of output values.
+#   conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn)
 #   # Execute a query.
 #   res = conn.exec_params( "SELECT $1::INT", ['5'] )
 #   # Retrieve and cast the result value. Value format is 0 (text) and OID is 20. Therefore typecasting
@@ -236,8 +237,28 @@ end
 #
 # PG::TypeMapByOid#fit_to_result(result, false) can be used to generate
 # a result independent PG::TypeMapByColumn type map, which can subsequently be used
-# to cast #get_copy_data fields. See also PG::BasicTypeMapBasedOnResult .
+# to cast #get_copy_data fields:
+#
+# For the following table:
+#   conn.exec( "CREATE TABLE copytable AS VALUES('a', 123, '{5,4,3}'::INT[])" )
 #
+#   # Retrieve table OIDs per empty result set.
+#   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
+#   # Build a type map for common database to ruby type decoders.
+#   btm = PG::BasicTypeMapForResults.new(conn)
+#   # Build a PG::TypeMapByColumn with decoders suitable for copytable.
+#   tm = btm.build_column_map( res )
+#   row_decoder = PG::TextDecoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable TO STDOUT", row_decoder ) do |res|
+#     while row=conn.get_copy_data
+#       p row
+#     end
+#   end
+# This prints the rows with type casted columns:
+#   ["a", 123, [5, 4, 3]]
+#
+# See also PG::BasicTypeMapBasedOnResult for the encoder direction.
 class PG::BasicTypeMapForResults < PG::TypeMapByOid
 	include PG::BasicTypeRegistry
 
@@ -290,12 +311,17 @@ end
 #
 #   # Retrieve table OIDs per empty result set.
 #   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
-#   tm = basic_type_mapping.build_column_map( res )
+#   # Build a type map for common ruby to database type encoders.
+#   btm = PG::BasicTypeMapBasedOnResult.new(conn)
+#   # Build a PG::TypeMapByColumn with encoders suitable for copytable.
+#   tm = btm.build_column_map( res )
 #   row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
 #
 #   conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|
 #     conn.put_copy_data ['a', 123, [5,4,3]]
 #   end
+# This inserts a single row into copytable with type casts from ruby to
+# database types.
 class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
 	include PG::BasicTypeRegistry
 
@@ -314,15 +340,16 @@ end
 # OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
 # PostgreSQL's pg_type table in PG::BasicTypeMapForQueries.new .
 #
-# Query params are type casted based on the MRI internal type of the given value.
+# Query params are type casted based on the class of the given value.
 #
 # Higher level libraries will most likely not make use of this class, but use their
-# own set of rules to choose suitable encoders and decoders.
+# own derivation of PG::TypeMapByClass or another set of rules to choose suitable
+# encoders and decoders for the values to be sent.
 #
 # Example:
 #   conn = PG::Connection.new
 #   # Assign a default ruleset for type casts of input and output values.
-#   conn.type_mapping_for_queries = PG::BasicTypeMapForQueries.new(conn)
+#   conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
 #   # Execute a query. The Integer param value is typecasted internally by PG::BinaryEncoder::Int8.
 #   # The format of the parameter is set to 1 (binary) and the OID of this parameter is set to 20 (int8).
 #   res = conn.exec_params( "SELECT $1", [5] )

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
 	#
@@ -100,12 +110,20 @@ class PG::Connection
 	# of #put_copy_data, #get_copy_data and #put_copy_end.
 	#
 	# Example with CSV input format:
-	#   conn.exec "create table my_table (a text,b text,c text,d text,e text)"
+	#   conn.exec "create table my_table (a text,b text,c text,d text)"
 	#   conn.copy_data "COPY my_table FROM STDIN CSV" do
-	#     conn.put_copy_data "some,csv,data,to,copy\n"
-	#     conn.put_copy_data "more,csv,data,to,copy\n"
+	#     conn.put_copy_data "some,data,to,copy\n"
+	#     conn.put_copy_data "more,data,to,copy\n"
+	#   end
+	# This creates +my_table+ and inserts two CSV rows.
+	#
+	# The same with text format encoder PG::TextEncoder::CopyRow
+	# and Array input:
+	#   enco = PG::TextEncoder::CopyRow.new
+	#   conn.copy_data "COPY my_table FROM STDIN", enco do
+	#     conn.put_copy_data ['some', 'data', 'to', 'copy']
+	#     conn.put_copy_data ['more', 'data', 'to', 'copy']
 	#   end
-	# This creates +my_table+ and inserts two rows.
 	#
 	# Example with CSV output format:
 	#   conn.copy_data "COPY my_table TO STDOUT CSV" do
@@ -114,8 +132,21 @@ class PG::Connection
 	#     end
 	#   end
 	# This prints all rows of +my_table+ to stdout:
-	#   "some,csv,data,to,copy\n"
-	#   "more,csv,data,to,copy\n"
+	#   "some,data,to,copy\n"
+	#   "more,data,to,copy\n"
+	#
+	# The same with text format decoder PG::TextDecoder::CopyRow
+	# and Array output:
+	#   deco = PG::TextDecoder::CopyRow.new
+	#   conn.copy_data "COPY my_table TO STDOUT", deco do
+	#     while row=conn.get_copy_data
+	#       p row
+	#     end
+	#   end
+	# This receives all rows of +my_table+ as ruby array:
+	#   ["some", "data", "to", "copy"]
+	#   ["more", "data", "to", "copy"]
+
 	def copy_data( sql, coder=nil )
 		res = exec( sql )
 
@@ -155,7 +186,7 @@ class PG::Connection
 				raise
 			else
 				res = get_last_result
-				if res.result_status != PGRES_COMMAND_OK
+				if !res || res.result_status != PGRES_COMMAND_OK
 					while get_copy_data
 					end
 					while get_result
@@ -214,8 +245,27 @@ class PG::Connection
 		end
 	end
 
+	# Method 'ssl_attribute' was introduced in PostgreSQL 9.5.
+	if self.instance_methods.find{|m| m.to_sym == :ssl_attribute }
+		# call-seq:
+		#   conn.ssl_attributes -> Hash<String,String>
+		#
+		# Returns SSL-related information about the connection as key/value pairs
+		#
+		# The available attributes varies depending on the SSL library being used,
+		# and the type of connection.
+		#
+		# See also #ssl_attribute
+		def ssl_attributes
+			ssl_attribute_names.each.with_object({}) do |n,h|
+				h[n] = ssl_attribute(n)
+			end
+		end
+	end
+
 end # class PG::Connection
 
+# :stopdoc:
 # Backward-compatible alias
 PGconn = PG::Connection