pg 0.18.0 → 1.1.4

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 fc1c4deb1398 2018/06/25 12:02:09 kanis $
  *
  */
 
@@ -15,9 +15,9 @@ static const char base64_encode_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijk
  * in-place (with _out_ == _in_).
  */
 void
-base64_encode( char *out, char *in, int len)
+base64_encode( char *out, const char *in, int len)
 {
-	char *in_ptr = in + len;
+	const unsigned char *in_ptr = (const unsigned char *)in + len;
 	char *out_ptr = out + BASE64_ENCODED_SIZE(len);
 	int part_len = len % 3;
 
@@ -72,12 +72,12 @@ static const unsigned char base64_decode_table[] =
  * It is possible to decode a string in-place (with _out_ == _in_).
  */
 int
-base64_decode( char *out, char *in, unsigned int len)
+base64_decode( char *out, const char *in, unsigned int len)
 {
 	unsigned char a, b, c, d;
-	unsigned char *in_ptr = (unsigned char *)in;
+	const unsigned char *in_ptr = (const unsigned char *)in;
 	unsigned char *out_ptr = (unsigned char *)out;
-	unsigned char *iend_ptr = (unsigned char *)in + len;
+	const unsigned char *iend_ptr = (unsigned char *)in + len;
 
 	for(;;){
 		if( in_ptr+3 < iend_ptr &&
@@ -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

@@ -57,9 +57,9 @@
 #define BASE64_ENCODED_SIZE(strlen) (((strlen) + 2) / 3 * 4)
 #define BASE64_DECODED_SIZE(base64len) (((base64len) + 3) / 4 * 3)
 
-void base64_encode( char *out, char *in, int len);
-int base64_decode( char *out, char *in, unsigned int len);
+void base64_encode( char *out, const char *in, int len);
+int base64_decode( char *out, const 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/basic_type_mapping.rb

@@ -1,7 +1,27 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
 
 require 'pg' unless defined?( PG )
 
+# This module defines the mapping between OID and encoder/decoder classes for PG::BasicTypeMapForResults, PG::BasicTypeMapForQueries and PG::BasicTypeMapBasedOnResult.
+#
+# Additional types can be added like so:
+#
+#   require 'pg'
+#   require 'ipaddr'
+#
+#   class InetDecoder < PG::SimpleDecoder
+#     def decode(string, tuple=nil, field=nil)
+#       IPAddr.new(string)
+#     end
+#   end
+#   class InetEncoder < PG::SimpleEncoder
+#     def encode(ip_addr)
+#       ip_addr.to_s
+#     end
+#   end
+#
+#   # 0 if for text format, can also be 1 for binary
+#   PG::BasicTypeRegistry.register_type(0, 'inet', InetEncoder, InetDecoder)
 module PG::BasicTypeRegistry
 	# An instance of this class stores the coders that should be used for a given wire format (text or binary)
 	# and type cast direction (encoder or decoder).
@@ -25,9 +45,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 +61,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 +82,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 }
@@ -137,6 +157,7 @@ module PG::BasicTypeRegistry
 	# Register an OID type named +name+ with a typecasting encoder and decoder object in
 	# +type+.  +name+ should correspond to the `typname` column in
 	# the `pg_type` table.
+	# +format+ can be 0 for text format and 1 for binary.
 	def self.register_type(format, name, encoder_class, decoder_class)
 		CODERS_BY_NAME[format] ||= { encoder: {}, decoder: {} }
 		CODERS_BY_NAME[format][:encoder][name] = encoder_class.new(name: name, format: format) if encoder_class
@@ -145,8 +166,14 @@ module PG::BasicTypeRegistry
 
 	# Alias the +old+ type to the +new+ type.
 	def self.alias_type(format, new, old)
-		CODERS_BY_NAME[format][:encoder][new] = CODERS_BY_NAME[format][:encoder][old]
-		CODERS_BY_NAME[format][:decoder][new] = CODERS_BY_NAME[format][:decoder][old]
+		[:encoder, :decoder].each do |ende|
+			enc = CODERS_BY_NAME[format][ende][old]
+			if enc
+				CODERS_BY_NAME[format][ende][new] = enc
+			else
+				CODERS_BY_NAME[format][ende].delete(new)
+			end
+		end
 	end
 
 	register_type 0, 'int2', PG::TextEncoder::Integer, PG::TextDecoder::Integer
@@ -154,46 +181,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', PG::TextEncoder::Numeric, PG::TextDecoder::Numeric
 	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 0, 'inet', PG::TextEncoder::Inet, PG::TextDecoder::Inet
+	alias_type 0, 'cidr', 'inet'
 
 
 
@@ -212,6 +240,8 @@ module PG::BasicTypeRegistry
 	register_type 1, 'bool', PG::BinaryEncoder::Boolean, PG::BinaryDecoder::Boolean
 	register_type 1, 'float4', nil, PG::BinaryDecoder::Float
 	register_type 1, 'float8', nil, PG::BinaryDecoder::Float
+	register_type 1, 'timestamp', nil, PG::BinaryDecoder::TimestampUtc
+	register_type 1, 'timestamptz', nil, PG::BinaryDecoder::TimestampUtcToLocal
 end
 
 # Simple set of rules for type casting common PostgreSQL types to Ruby.
@@ -226,8 +256,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 +266,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 and PG::BasicTypeRegistry for the definition of additional types.
 class PG::BasicTypeMapForResults < PG::TypeMapByOid
 	include PG::BasicTypeRegistry
 
@@ -290,12 +340,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 +369,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] )
@@ -385,6 +441,10 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		# to unnecessary type conversions on server side.
 		Integer => [0, 'int8'],
 		Float => [0, 'float8'],
+		BigDecimal => [0, 'numeric'],
+		# We use text format and no type OID for IPAddr, because setting the OID can lead
+		# to unnecessary inet/cidr conversions on the server side.
+		IPAddr => [0, 'inet'],
 		Array => :get_array_type,
 	}
 

data/lib/pg/binary_decoder.rb

@@ -0,0 +1,22 @@
+# -*- ruby -*-
+
+module PG
+	module BinaryDecoder
+		# Convenience classes for timezone options
+		class TimestampUtc < Timestamp
+			def initialize(params={})
+				super(params.merge(flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_UTC))
+			end
+		end
+		class TimestampUtcToLocal < Timestamp
+			def initialize(params={})
+				super(params.merge(flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_LOCAL))
+			end
+		end
+		class TimestampLocal < Timestamp
+			def initialize(params={})
+				super(params.merge(flags: PG::Coder::TIMESTAMP_DB_LOCAL | PG::Coder::TIMESTAMP_APP_LOCAL))
+			end
+		end
+	end
+end # module PG

data/lib/pg/coder.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
 
 module PG
 

data/lib/pg/connection.rb

@@ -1,6 +1,7 @@
-#!/usr/bin/env ruby
+# -*- 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,48 +35,57 @@ 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, /\A#{URI.regexp}\z/
+				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
+	#     conn.copy_data( sql [, coder] ) {|sql_result| ... } -> PG::Result
 	#
 	# Execute a copy process for transfering data to or from the server.
 	#
@@ -99,13 +109,26 @@ class PG::Connection
 	# of blocking mode of operation, #copy_data is preferred to raw calls
 	# of #put_copy_data, #get_copy_data and #put_copy_end.
 	#
+	# _coder_ can be a PG::Coder derivation
+	# (typically PG::TextEncoder::CopyRow or PG::TextDecoder::CopyRow).
+	# This enables encoding of data fields given to #put_copy_data
+	# or decoding of fields received by #get_copy_data.
+	#
 	# 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 +137,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 +191,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 +250,42 @@ class PG::Connection
 		end
 	end
 
-end # class PG::Connection
+	# 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
+
+	REDIRECT_METHODS = {
+		:exec => [:async_exec, :sync_exec],
+		:query => [:async_exec, :sync_exec],
+		:exec_params => [:async_exec_params, :sync_exec_params],
+		:prepare => [:async_prepare, :sync_prepare],
+		:exec_prepared => [:async_exec_prepared, :sync_exec_prepared],
+		:describe_portal => [:async_describe_portal, :sync_describe_portal],
+		:describe_prepared => [:async_describe_prepared, :sync_describe_prepared],
+	}
+
+	def self.async_api=(enable)
+		REDIRECT_METHODS.each do |ali, (async, sync)|
+			remove_method(ali) if method_defined?(ali)
+			alias_method( ali, enable ? async : sync )
+		end
+	end
 
-# Backward-compatible alias
-PGconn = PG::Connection
+	# pg-1.1.0+ defaults to libpq's async API for query related blocking methods
+	self.async_api = true
+end # class PG::Connection
 

data/lib/pg/constants.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
 
 require 'pg' unless defined?( PG )
 

data/lib/pg/exceptions.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
 
 require 'pg' unless defined?( PG )
 

data/lib/pg/result.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
 
 require 'pg' unless defined?( PG )
 
@@ -12,15 +12,20 @@ class PG::Result
 	# See PG::BasicTypeMapForResults
 	def map_types!(type_map)
 		self.type_map = type_map
-		self
+		return self
 	end
 
+
+	### Return a String representation of the object suitable for debugging.
 	def inspect
 		str = self.to_s
-		str[-1,0] = " status=#{res_status(result_status)} ntuples=#{ntuples} nfields=#{nfields} cmd_tuples=#{cmd_tuples}"
-		str
+		str[-1,0] = if cleared?
+			" cleared"
+		else
+			" status=#{res_status(result_status)} ntuples=#{ntuples} nfields=#{nfields} cmd_tuples=#{cmd_tuples}"
+		end
+		return str
 	end
+
 end # class PG::Result
 
-# Backward-compatible alias
-PGresult = PG::Result

data/lib/pg/text_decoder.rb

@@ -1,4 +1,7 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+
+require 'date'
+require 'json'
 
 module PG
 	module TextDecoder
@@ -7,36 +10,38 @@ module PG
 
 			def decode(string, tuple=nil, field=nil)
 				if string =~ ISO_DATE
-					Time.new $1.to_i, $2.to_i, $3.to_i
+					::Date.new $1.to_i, $2.to_i, $3.to_i
 				else
 					string
 				end
 			end
 		end
 
-		class TimestampWithoutTimeZone < SimpleDecoder
-			ISO_DATETIME_WITHOUT_TIMEZONE = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-
+		class JSON < SimpleDecoder
 			def decode(string, tuple=nil, field=nil)
-				if string =~ ISO_DATETIME_WITHOUT_TIMEZONE
-					Time.new $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, "#{$6}#{$7}".to_r
-				else
-					string
-				end
+				::JSON.parse(string, quirks_mode: true)
 			end
 		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/
-
-			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"
-				else
-					string
-				end
+		# Convenience classes for timezone options
+		class TimestampUtc < Timestamp
+			def initialize(params={})
+				super(params.merge(flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_UTC))
+			end
+		end
+		class TimestampUtcToLocal < Timestamp
+			def initialize(params={})
+				super(params.merge(flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_LOCAL))
 			end
 		end
+		class TimestampLocal < Timestamp
+			def initialize(params={})
+				super(params.merge(flags: PG::Coder::TIMESTAMP_DB_LOCAL | PG::Coder::TIMESTAMP_APP_LOCAL))
+			end
+		end
+
+		# For backward compatibility:
+		TimestampWithoutTimeZone = TimestampLocal
+		TimestampWithTimeZone = Timestamp
 	end
 end # module PG
-