pg 0.18.0 → 1.0.0

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,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,23 @@ 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
 
-# Backward-compatible alias
-PGconn = PG::Connection
+end # class PG::Connection
 

data/lib/pg/result.rb

@@ -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,5 +1,8 @@
 #!/usr/bin/env ruby
 
+require 'date'
+require 'json'
+
 module PG
 	module TextDecoder
 		class Date < SimpleDecoder
@@ -7,7 +10,7 @@ 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
@@ -27,16 +30,22 @@ 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
 			end
 		end
+
+		class JSON < SimpleDecoder
+			def decode(string, tuple=nil, field=nil)
+				::JSON.parse(string, quirks_mode: true)
+			end
+		end
 	end
 end # module PG
 

data/lib/pg/text_encoder.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'json'
+
 module PG
 	module TextEncoder
 		class Date < SimpleEncoder
@@ -22,6 +24,12 @@ module PG
 				value.respond_to?(:strftime) ? value.strftime(STRFTIME_ISO_DATETIME_WITH_TIMEZONE) : value
 			end
 		end
+
+		class JSON < SimpleEncoder
+			def encode(value)
+				::JSON.generate(value, quirks_mode: true)
+			end
+		end
 	end
 end # module PG
 

data/lib/pg.rb

@@ -8,11 +8,22 @@ rescue LoadError
 		major_minor = RUBY_VERSION[ /^(\d+\.\d+)/ ] or
 			raise "Oops, can't extract the major/minor version from #{RUBY_VERSION.dump}"
 
-		# 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}"
-		require "#{major_minor}/pg_ext"
-		ENV['PATH'] = old_path
+		add_dll_path = proc do |path, &block|
+			begin
+				require 'ruby_installer/runtime'
+				RubyInstaller::Runtime.add_dll_directory(path, &block)
+			rescue LoadError
+				old_path = ENV['PATH']
+				ENV['PATH'] = "#{path};#{old_path}"
+				block.call
+				ENV['PATH'] = old_path
+			end
+		end
+
+		# Temporary add this directory for DLL search, so that libpq.dll can be found.
+		add_dll_path.call(__dir__) do
+			require "#{major_minor}/pg_ext"
+		end
 	else
 		raise
 	end
@@ -24,10 +35,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.18.0'
+	VERSION = '1.0.0'
 
 	# VCS revision
-	REVISION = %q$Revision: b2bf034e3b9f $
+	REVISION = %q$Revision: fef434914848 $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end
@@ -59,6 +70,3 @@ module PG
 end # module PG
 
 
-# Backward-compatible aliase
-PGError = PG::Error
-

data/spec/helpers.rb

@@ -5,7 +5,9 @@ require 'rspec'
 require 'shellwords'
 require 'pg'
 
-TEST_DIRECTORY = Pathname.getwd + "tmp_test_specs"
+DEFAULT_TEST_DIR_STR = File.join(Dir.pwd, "tmp_test_specs")
+TEST_DIR_STR = ENV['RUBY_PG_TEST_DIR'] || DEFAULT_TEST_DIR_STR
+TEST_DIRECTORY = Pathname.new(TEST_DIR_STR)
 
 module PG::TestingHelpers
 
@@ -251,11 +253,11 @@ module PG::TestingHelpers
 
 	def check_for_lingering_connections( conn )
 		conn.exec( "SELECT * FROM pg_stat_activity" ) do |res|
-			conns = res.find_all {|row| row['pid'].to_i != conn.backend_pid }
+			conns = res.find_all {|row| row['pid'].to_i != conn.backend_pid && ["client backend", nil].include?(row["backend_type"]) }
 			unless conns.empty?
 				puts "Lingering connections remain:"
 				conns.each do |row|
-					puts "  [%d] {%s} %s -- %s" % row.values_at( 'pid', 'state', 'application_name', 'query' )
+					puts "  [%s] {%s} %s -- %s" % row.values_at( 'pid', 'state', 'application_name', 'query' )
 				end
 			end
 		end
@@ -339,17 +341,8 @@ RSpec.configure do |config|
 	config.filter_run_excluding :socket_io unless
 		PG::Connection.instance_methods.map( &:to_sym ).include?( :socket_io )
 
-	config.filter_run_excluding :postgresql_90 unless
-		PG::Connection.instance_methods.map( &:to_sym ).include?( :escape_literal )
-
-	if !PG.respond_to?( :library_version )
-		config.filter_run_excluding( :postgresql_91, :postgresql_92, :postgresql_93, :postgresql_94 )
-	elsif PG.library_version < 90200
-		config.filter_run_excluding( :postgresql_92, :postgresql_93, :postgresql_94 )
-	elsif PG.library_version < 90300
-		config.filter_run_excluding( :postgresql_93, :postgresql_94 )
-	elsif PG.library_version < 90400
-		config.filter_run_excluding( :postgresql_94 )
-	end
+	config.filter_run_excluding( :postgresql_93 ) if PG.library_version <  90300
+	config.filter_run_excluding( :postgresql_94 ) if PG.library_version <  90400
+	config.filter_run_excluding( :postgresql_95 ) if PG.library_version <  90500
+	config.filter_run_excluding( :postgresql_10 ) if PG.library_version < 100000
 end
-

data/spec/pg/basic_type_mapping_spec.rb

@@ -58,8 +58,8 @@ describe 'Basic type mapping' do
 		it "should do OID based type conversions", :ruby_19 do
 			res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, TRUE, '2013-06-30'::DATE, generate_series(4,5)" )
 			expect( res.map_types!(basic_type_mapping).values ).to eq( [
-					[ 1, 'a', 2.0, true, Time.new(2013,6,30), 4 ],
-					[ 1, 'a', 2.0, true, Time.new(2013,6,30), 5 ],
+					[ 1, 'a', 2.0, true, Date.new(2013,6,30), 4 ],
+					[ 1, 'a', 2.0, true, Date.new(2013,6,30), 5 ],
 			] )
 		end
 
@@ -159,13 +159,34 @@ describe 'Basic type mapping' do
 																		CAST('1913-12-31' AS DATE),
 																		CAST('infinity' AS DATE),
 																		CAST('-infinity' AS DATE)", [], format )
-					expect( res.getvalue(0,0) ).to eq( Time.new(2113, 12, 31) )
-					expect( res.getvalue(0,1) ).to eq( Time.new(1913, 12, 31) )
+					expect( res.getvalue(0,0) ).to eq( Date.new(2113, 12, 31) )
+					expect( res.getvalue(0,1) ).to eq( Date.new(1913, 12, 31) )
 					expect( res.getvalue(0,2) ).to eq( 'infinity' )
 					expect( res.getvalue(0,3) ).to eq( '-infinity' )
 				end
 			end
 
+			it "should do JSON conversions", :postgresql_94 do
+				[0].each do |format|
+					['JSON', 'JSONB'].each do |type|
+						res = @conn.exec( "SELECT CAST('123' AS #{type}),
+																			CAST('12.3' AS #{type}),
+																			CAST('true' AS #{type}),
+																			CAST('false' AS #{type}),
+																			CAST('null' AS #{type}),
+																			CAST('[1, \"a\", null]' AS #{type}),
+																			CAST('{\"b\" : [2,3]}' AS #{type})", [], format )
+						expect( res.getvalue(0,0) ).to eq( 123 )
+						expect( res.getvalue(0,1) ).to be_within(0.1).of( 12.3 )
+						expect( res.getvalue(0,2) ).to eq( true )
+						expect( res.getvalue(0,3) ).to eq( false )
+						expect( res.getvalue(0,4) ).to eq( nil )
+						expect( res.getvalue(0,5) ).to eq( [1, "a", nil] )
+						expect( res.getvalue(0,6) ).to eq( {"b" => [2, 3]} )
+					end
+				end
+			end
+
 			it "should do array type conversions" do
 				[0].each do |format|
 					res = @conn.exec( "SELECT CAST('{1,2,3}' AS INT2[]), CAST('{{1,2},{3,4}}' AS INT2[][]),
@@ -228,6 +249,39 @@ describe 'Basic type mapping' do
 				res = @conn.exec( "SELECT * FROM copytable" )
 				expect( res.values ).to eq( [['a', '123', '{5,4,3}'], ['b', '234', '{2,3}']] )
 			end
+
+			it "can do JSON conversions", :postgresql_94 do
+				['JSON', 'JSONB'].each do |type|
+					sql = "SELECT CAST('123' AS #{type}),
+						CAST('12.3' AS #{type}),
+						CAST('true' AS #{type}),
+						CAST('false' AS #{type}),
+						CAST('null' AS #{type}),
+						CAST('[1, \"a\", null]' AS #{type}),
+						CAST('{\"b\" : [2,3]}' AS #{type})"
+
+					tm = basic_type_mapping.build_column_map( @conn.exec( sql ) )
+					expect( tm.coders.map(&:name) ).to eq( [type.downcase] * 7 )
+
+					res = @conn.exec_params( "SELECT $1, $2, $3, $4, $5, $6, $7",
+						[ 123,
+							12.3,
+							true,
+							false,
+							nil,
+							[1, "a", nil],
+							{"b" => [2, 3]},
+						], 0, tm )
+
+					expect( res.getvalue(0,0) ).to eq( "123" )
+					expect( res.getvalue(0,1) ).to eq( "12.3" )
+					expect( res.getvalue(0,2) ).to eq( "true" )
+					expect( res.getvalue(0,3) ).to eq( "false" )
+					expect( res.getvalue(0,4) ).to eq( nil )
+					expect( res.getvalue(0,5).gsub(" ","") ).to eq( "[1,\"a\",null]" )
+					expect( res.getvalue(0,6).gsub(" ","") ).to eq( "{\"b\":[2,3]}" )
+				end
+			end
 		end
 
 		context "with usage of result oids for copy encoder selection" do