pg 0.18.3 → 1.0.0

data/lib/pg/basic_type_mapping.rb

@@ -188,7 +188,8 @@ module PG::BasicTypeRegistry
 	# 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 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
 	#
@@ -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

@@ -47,7 +47,7 @@ class PG::Connection
 
 		if args.length == 1
 			case args.first
-			when URI, URI.regexp
+			when URI, /\A#{URI.regexp}\z/
 				uri = URI(args.first)
 				options.merge!( Hash[URI.decode_www_form( uri.query )] ) if uri.query
 			when /=/
@@ -85,7 +85,7 @@ class PG::Connection
 
 
 	#  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.
 	#
@@ -109,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
@@ -124,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 )
 
@@ -165,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
@@ -224,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,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'date'
+require 'json'
 
 module PG
 	module TextDecoder
@@ -39,6 +40,12 @@ module PG
 				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.3'
+	VERSION = '1.0.0'
 
 	# VCS revision
-	REVISION = %q$Revision: 3b49541c9f12 $
+	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,7 +253,7 @@ 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|
@@ -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

@@ -166,6 +166,27 @@ describe 'Basic type mapping' do
 				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