pg 0.18.0.pre20141117110243-x64-mingw32 → 0.18.0-x64-mingw32

data/lib/pg.rb

@@ -24,7 +24,7 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.18.0.pre20141117110243'
+	VERSION = '0.18.0'
 
 	# VCS revision
 	REVISION = %q$Revision$

data/lib/pg/basic_type_mapping.rb

@@ -71,11 +71,13 @@ module PG::BasicTypeRegistry
 			@coders = coder_map.values
 			@coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }
 			@coders_by_oid = @coders.inject({}){|h, t| h[t.oid] = t; h }
+			@typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }
 		end
 
 		attr_reader :coders
 		attr_reader :coders_by_oid
 		attr_reader :coders_by_name
+		attr_reader :typenames_by_oid
 
 		def coder_by_name(name)
 			@coders_by_name[name]
@@ -125,7 +127,7 @@ module PG::BasicTypeRegistry
 		raise(ArgumentError, "Invalid format value %p" % format) unless ValidFormats[format]
 		raise(ArgumentError, "Invalid direction %p" % direction) unless ValidDirections[direction]
 	end
-
+	protected :check_format_and_direction
 
 	# The key of this hash maps to the `typname` column from the table.
 	# encoder_map is then dynamically built with oids as the key and Type
@@ -239,6 +241,23 @@ end
 class PG::BasicTypeMapForResults < PG::TypeMapByOid
 	include PG::BasicTypeRegistry
 
+	class WarningTypeMap < PG::TypeMapInRuby
+		def initialize(typenames)
+			@already_warned = Hash.new{|h, k| h[k] = {} }
+			@typenames_by_oid = typenames
+		end
+
+		def typecast_result_value(result, _tuple, field)
+			format = result.fformat(field)
+			oid = result.ftype(field)
+			unless @already_warned[format][oid]
+				STDERR.puts "Warning: no type cast defined for type #{@typenames_by_oid[format][oid].inspect} with oid #{oid}. Please cast this type explicitly to TEXT to be safe for future changes."
+				 @already_warned[format][oid] = true
+			end
+			super
+		end
+	end
+
 	def initialize(connection)
 		@coder_maps = build_coder_maps(connection)
 
@@ -246,6 +265,9 @@ class PG::BasicTypeMapForResults < PG::TypeMapByOid
 		@coder_maps.map{|f| f[:decoder].coders }.flatten.each do |coder|
 			add_coder(coder)
 		end
+
+		typenames = @coder_maps.map{|f| f[:decoder].typenames_by_oid }
+		self.default_type_map = WarningTypeMap.new(typenames)
 	end
 end
 
@@ -259,7 +281,7 @@ end
 # the given result OIDs, but encoders. So it can be used to type cast field values based on
 # the type OID retrieved by a separate SQL query.
 #
-# PG::TypeMapByOid#fit_to_result(result, false) can be used to generate a result independent
+# PG::TypeMapByOid#build_column_map(result) can be used to generate a result independent
 # PG::TypeMapByColumn type map, which can subsequently be used to cast query bind parameters
 # or #put_copy_data fields.
 #
@@ -268,7 +290,7 @@ end
 #
 #   # Retrieve table OIDs per empty result set.
 #   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
-#   tm = basic_type_mapping.fit_to_result( res, false )
+#   tm = basic_type_mapping.build_column_map( res )
 #   row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
 #
 #   conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|

data/lib/pg/connection.rb

@@ -101,7 +101,7 @@ class PG::Connection
 	#
 	# Example with CSV input format:
 	#   conn.exec "create table my_table (a text,b text,c text,d text,e text)"
-	#   conn.copy_data "COPY my_table FROM STDOUT CSV" do
+	#   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"
 	#   end

data/spec/pg/basic_type_mapping_spec.rb

@@ -195,7 +195,7 @@ describe 'Basic type mapping' do
 
 				# Retrieve table OIDs per empty result.
 				res = @conn.exec( "SELECT * FROM copytable LIMIT 0" )
-				tm = basic_type_mapping.fit_to_result( res, false )
+				tm = basic_type_mapping.build_column_map( res )
 				row_decoder = PG::TextDecoder::CopyRow.new type_map: tm
 
 				rows = []
@@ -221,7 +221,7 @@ describe 'Basic type mapping' do
 
 				# Retrieve table OIDs per empty result.
 				res = @conn.exec( "SELECT * FROM copytable LIMIT 0" )
-				tm = basic_type_mapping.fit_to_result( res, false )
+				tm = basic_type_mapping.build_column_map( res )
 
 				@conn.exec_params( "INSERT INTO copytable VALUES ($1, $2, $3)", ['a', 123, [5,4,3]], 0, tm )
 				@conn.exec_params( "INSERT INTO copytable VALUES ($1, $2, $3)", ['b', 234, [2,3]], 0, tm )
@@ -236,7 +236,7 @@ describe 'Basic type mapping' do
 
 				# Retrieve table OIDs per empty result set.
 				res = @conn.exec( "SELECT * FROM copytable LIMIT 0" )
-				tm = basic_type_mapping.fit_to_result( res, false )
+				tm = basic_type_mapping.build_column_map( res )
 				row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
 
 				@conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|

data/spec/pg/type_map_by_class_spec.rb

@@ -133,6 +133,6 @@ describe PG::TypeMapByClass do
 		tm[TrueClass] = "dummy"
 		expect{
 			res = @conn.exec_params( "SELECT $1", [true], 0, tm )
-		}.to raise_error(NoMethodError, /undefined method.*call.*dummy/)
+		}.to raise_error(NoMethodError, /undefined method.*call/)
 	end
 end

data/spec/pg/type_map_by_oid_spec.rb

@@ -77,10 +77,7 @@ describe PG::TypeMapByOid do
 
 	it "should allow building new TypeMapByColumn for a given result" do
 		res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		tm2 = tm.fit_to_result(res, true)
-		expect( tm2 ).to eq( tm )
-
-		tm2 = tm.fit_to_result(res, false)
+		tm2 = tm.build_column_map(res)
 		expect( tm2 ).to be_a_kind_of(PG::TypeMapByColumn)
 		expect( tm2.coders ).to eq( [textdec_int, nil, textdec_float, pass_through_type] )
 	end
@@ -118,7 +115,6 @@ describe PG::TypeMapByOid do
 
 	it "should build a TypeMapByColumn when assigned and the number of rows is high enough" do
 		res = @conn.exec( "SELECT generate_series(1,20), 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		expect( tm.fit_to_result(res) ).to be_a_kind_of(PG::TypeMapByColumn)
 		res.type_map = tm
 		expect( res.type_map ).to be_kind_of( PG::TypeMapByColumn )
 		expect( res.type_map.coders ).to eq( [textdec_int, nil, textdec_float, pass_through_type] )
@@ -126,7 +122,6 @@ describe PG::TypeMapByOid do
 
 	it "should use TypeMapByOid for online lookup and the number of rows is low enough" do
 		res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		expect( tm.fit_to_result(res) ).to eq( tm )
 		res.type_map = tm
 		expect( res.type_map ).to be_kind_of( PG::TypeMapByOid )
 	end

data/spec/pg/type_map_in_ruby_spec.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/env rspec
+# encoding: utf-8
+
+require_relative '../helpers'
+
+require 'pg'
+
+
+describe PG::TypeMapInRuby do
+
+	context "result values" do
+		it "should be usable non-derived" do
+			tm = PG::TypeMapInRuby.new
+			res = @conn.exec("select 5").map_types!(tm)
+			expect( res.getvalue(0,0) ).to eq( "5" )
+		end
+
+		it "should call derived result mapping methods" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				attr_reader :fit_to_result_args
+
+				def fit_to_result(*args)
+					@fit_to_result_args = args
+					self
+				end
+
+				def typecast_result_value(*args)
+					[args, super]
+				end
+			end.new
+
+			res = @conn.exec("select 5,6").map_types!(tm)
+			expect( res.getvalue(0,1) ).to eq( [[res, 0, 1], "6"] )
+			expect( tm.fit_to_result_args ).to eq( [res] )
+		end
+
+		it "should accept only a type map object from fit_to_result" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				def fit_to_result(*args)
+					:invalid
+				end
+			end.new
+
+			res = @conn.exec("select 5,6")
+			expect{ res.map_types!(tm) }.to raise_error(TypeError, /kind of PG::TypeMap/)
+		end
+	end
+
+	context "query bind params" do
+		it "should be usable non-derived" do
+			tm = PG::TypeMapInRuby.new
+			res = @conn.exec_params("select $1::int, $2::text", [5, 6], 0, tm)
+			expect( res.values ).to eq( [["5", "6"]] )
+		end
+
+		it "should call derived param mapping methods" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				attr_reader :fit_to_query_args
+				attr_reader :typecast_query_param_args
+
+				def fit_to_query(params)
+					@fit_to_query_args = params
+					@typecast_query_param_args = []
+					self
+				end
+
+				def typecast_query_param(*args)
+					@typecast_query_param_args << [args, super]
+					PG::TextEncoder::Integer.new name: 'INT4', oid: 23
+				end
+			end.new
+
+			res = @conn.exec_params("select $1, $2", [5, 6], 0, tm)
+			expect( res.ftype(0) ).to eq( 23 )
+			expect( tm.fit_to_query_args ).to eq( [5, 6] )
+			expect( tm.typecast_query_param_args ).to eq( [[[5, 0], nil], [[6, 1], nil]] )
+		end
+	end
+
+	context "put_copy_data" do
+		it "should be usable non-derived" do
+			tm = PG::TypeMapInRuby.new
+			ce = PG::TextEncoder::CopyRow.new type_map: tm
+			res = ce.encode([5, 6])
+			expect( res ).to eq( "5\t6\n" )
+		end
+
+		it "should call derived data mapping methods" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				attr_reader :fit_to_query_args
+				attr_reader :typecast_query_param_args
+
+				def fit_to_query(params)
+					@fit_to_query_args = params
+					@typecast_query_param_args = []
+					self
+				end
+
+				def typecast_query_param(*args)
+					@typecast_query_param_args << [args, super]
+					PG::TextEncoder::Integer.new name: 'INT4', oid: 23
+				end
+			end.new
+
+			ce = PG::TextEncoder::CopyRow.new type_map: tm
+			res = ce.encode([5, 6])
+			expect( res ).to eq( "5\t6\n" )
+			expect( tm.fit_to_query_args ).to eq( [5, 6] )
+			expect( tm.typecast_query_param_args ).to eq( [[[5, 0], nil], [[6, 1], nil]] )
+		end
+
+		it "shouldn't accept invalid return from typecast_query_param" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				def typecast_query_param(*args)
+					:invalid
+				end
+			end.new
+
+			ce = PG::TextEncoder::CopyRow.new type_map: tm
+			expect{ ce.encode([5, 6]) }.to raise_error(TypeError, /nil or kind of PG::Coder/)
+		end
+	end
+
+	context "get_copy_data" do
+		it "should be usable non-derived" do
+			tm = PG::TypeMapInRuby.new
+			ce = PG::TextDecoder::CopyRow.new type_map: tm
+			res = ce.decode("5\t6\n")
+			expect( res ).to eq( ["5", "6"] )
+		end
+
+		it "should call derived data mapping methods" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				attr_reader :fit_to_copy_get_args
+
+				def fit_to_copy_get(*args)
+					@fit_to_copy_get_args = args
+					0
+				end
+
+				def typecast_copy_get(field_str, fieldno, format, enc)
+					[field_str, fieldno, format, enc, super]
+				end
+			end.new
+
+			ce = PG::TextDecoder::CopyRow.new type_map: tm
+			res = ce.decode("5\t6\n")
+			expect( tm.fit_to_copy_get_args ).to eq( [] )
+			expect( res ).to eq( [["5", 0, 0, Encoding::UTF_8, "5"], ["6", 1, 0, Encoding::UTF_8, "6"]] )
+		end
+
+		it "shouldn't accept invalid return from fit_to_copy_get" do
+			tm = Class.new(PG::TypeMapInRuby) do
+				def fit_to_copy_get
+					:invalid
+				end
+			end.new
+
+			ce = PG::TextDecoder::CopyRow.new type_map: tm
+			expect{ ce.decode("5\t6\n") }.to raise_error(TypeError, /kind of Integer/)
+		end
+	end
+
+end

data/spec/pg/type_map_spec.rb

@@ -9,23 +9,6 @@ require 'pg'
 describe PG::TypeMap do
 	let!(:tm){ PG::TypeMap.new }
 
-	it "should respond to fit_to_query" do
-		expect{ tm.fit_to_query( [123] ) }.to raise_error(NotImplementedError, /not suitable to map query params/)
-	end
-
-	it "should respond to fit_to_result" do
-		res = @conn.exec( "SELECT 1" )
-		expect{ tm.fit_to_result( res ) }.to raise_error(NotImplementedError, /not suitable to map result values/)
-	end
-
-	it "should check params type" do
-		expect{ tm.fit_to_query( :invalid ) }.to raise_error(TypeError, /expected Array/)
-	end
-
-	it "should check result class" do
-		expect{ tm.fit_to_result( :invalid ) }.to raise_error(TypeError, /expected kind of PG::Result/)
-	end
-
 	it "should raise an error when used for param type casts" do
 		expect{
 			@conn.exec_params( "SELECT $1", [5], 0, tm )

data/spec/pg/type_spec.rb

@@ -138,15 +138,11 @@ describe "PG::Type derivations" do
 				expect( textenc_int.encode("  123-xyz  ") ).to eq( "123" )
 			end
 
-			it "should encode false and 0 to SQL FALSE value" do
-				[false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].each do |value|
-					expect( textenc_boolean.encode(value) ).to eq( "f" )
-				end
-			end
-
-			it "should encode true, 1 to SQL TRUE value" do
-				[true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].each do |value|
-					expect( textenc_boolean.encode(value) ).to eq( "t" )
+			it "should encode boolean values" do
+				expect( textenc_boolean.encode(false) ).to eq( "f" )
+				expect( textenc_boolean.encode(true) ).to eq( "t" )
+				["any", :other, "value", 0, 1, 2].each do |value|
+					expect( textenc_boolean.encode(value) ).to eq( value.to_s )
 				end
 			end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg
 version: !ruby/object:Gem::Version
-  version: 0.18.0.pre20141117110243
+  version: 0.18.0
 platform: x64-mingw32
 authors:
 - Michael Granger
@@ -30,7 +30,7 @@ cert_chain:
   GrqF74zpLl7/KFdHC8VmzwZS18hvDjxeLVuVI2gIGnBInqnlqv05g/l4/1pISh5j
   dS4=
   -----END CERTIFICATE-----
-date: 2014-11-17 00:00:00.000000000 Z
+date: 2015-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe-mercurial
@@ -197,6 +197,7 @@ extra_rdoc_files:
 - ext/pg_type_map_by_column.c
 - ext/pg_type_map_by_mri_type.c
 - ext/pg_type_map_by_oid.c
+- ext/pg_type_map_in_ruby.c
 - ext/util.c
 files:
 - ".gemtest"
@@ -236,6 +237,7 @@ files:
 - ext/pg_type_map_by_column.c
 - ext/pg_type_map_by_mri_type.c
 - ext/pg_type_map_by_oid.c
+- ext/pg_type_map_in_ruby.c
 - ext/util.c
 - ext/util.h
 - ext/vc/pg.sln
@@ -243,6 +245,7 @@ files:
 - ext/vc/pg_19/pg_19.vcproj
 - lib/2.0/pg_ext.so
 - lib/2.1/pg_ext.so
+- lib/2.2/pg_ext.so
 - lib/pg.rb
 - lib/pg/basic_type_mapping.rb
 - lib/pg/coder.rb
@@ -282,6 +285,7 @@ files:
 - spec/pg/type_map_by_column_spec.rb
 - spec/pg/type_map_by_mri_type_spec.rb
 - spec/pg/type_map_by_oid_spec.rb
+- spec/pg/type_map_in_ruby_spec.rb
 - spec/pg/type_map_spec.rb
 - spec/pg/type_spec.rb
 - spec/pg_spec.rb
@@ -308,12 +312,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Pg is the Ruby interface to the {PostgreSQL RDBMS}[http://www.postgresql.org/]