pg 0.18.0.pre20141017155815 → 0.18.0.pre20141017160319

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95311a9d99ccb8ee189f70f82db3c3246482cf5f
-  data.tar.gz: 72e13155d8032762a39b0628b882acb55325f8a2
+  metadata.gz: db79067db275bd6f5d8fb5194610716de4eba838
+  data.tar.gz: 30aa3c6d3ea706306adc3059b16349429f2c15c6
 SHA512:
-  metadata.gz: 2497dbc6ea9a9ea96fc6731b548b7d0c49c38be819b5b4eb927f432483e7df35603bf4247a14936cb566702ff6c90361e4e9cd815c97d75ca88b367ac8fdc184
-  data.tar.gz: d8475aef22cda0e31655b5edb58838b83c6dafe2e2fd5f10a051901af817c80f2d569a97d096bbdbbf1ef6f67017666661acedef70364010bacdddc5bce5f640
+  metadata.gz: 76c17fe2bbbdcf10ffe5e6ba71fde8babc6723ff8a3673455fc647a77f8f718caecf77cab6e255a45c46db01cfaa1fde83db75a26cb39712e10e462f143629ed
+  data.tar.gz: 77b0e5b2993e2c1a2c5a31a7ad2ffd3bd2ed292111e07bf6fc96f85074001d9434f2a9e6614aefb5f931c0534b4ba1611de54e9f0000e558790606f88aeab5ac

data/ChangeLog

@@ -1,10 +1,28 @@
+2014-10-15  Lars Kanis  <lars@greiz-reinsdorf.de>
+
+	* ext/pg_text_encoder.c, spec/pg/type_spec.rb:
+	Allow non Array values as input for TextEncoder::Array.
+	[a4725dfca9e4] [tip]
+
+	* ext/pg_coder.c, spec/pg/type_spec.rb:
+	Clarify handling of nil/NULL values by PG::Coders.
+	[99d6acb8b66d]
+
+	* ext/pg_text_encoder.c, ext/util.c, ext/util.h:
+	Move pg_strncasecmp() to util.c - it better fits there.
+	[117fb5c5eed7]
+
 2014-10-14  Lars Kanis  <lars@greiz-reinsdorf.de>
 
+	* ext/pg_text_encoder.c, spec/pg/type_spec.rb:
+	Implement a more serious TestEncoder::Boolean.
+	[9063a84a2ff9]
+
 	* ext/pg.h, ext/pg_binary_encoder.c, ext/pg_coder.c,
 	ext/pg_text_encoder.c:
 	Fix naming and description of pg_coder_enc_to_s(). It actually uses
 	#to_s not #to_str.
-	[ac23631c96d9] [github/master, tip]
+	[ac23631c96d9] [github/master]
 
 	* ext/pg_text_encoder.c, spec/pg/type_spec.rb:
 	Use same rules for array quoting in text encoder as PostgreSQL.

data/ext/pg_coder.c

@@ -109,6 +109,8 @@ pg_composite_decoder_allocate( VALUE klass )
  * Encodes the given Ruby object into string representation, without
  * sending data to/from the database server.
  *
+ * A nil value is passed through.
+ *
  */
 static VALUE
 pg_coder_encode(VALUE self, VALUE value)
@@ -118,6 +120,9 @@ pg_coder_encode(VALUE self, VALUE value)
 	int len, len2;
 	t_pg_coder *this = DATA_PTR(self);
 
+	if( NIL_P(value) )
+		return Qnil;
+
 	if( !this->enc_func ){
 		rb_raise(rb_eRuntimeError, "no encoder function defined");
 	}
@@ -151,6 +156,9 @@ pg_coder_encode(VALUE self, VALUE value)
  * Decodes the given string representation into a Ruby object, without
  * sending data to/from the database server.
  *
+ * A nil value is passed through and non String values are expected to have
+ * #to_str defined.
+ *
  */
 static VALUE
 pg_coder_decode(int argc, VALUE *argv, VALUE self)
@@ -168,6 +176,9 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 		field = NUM2INT(argv[2]);
 	}
 
+	if( NIL_P(argv[0]) )
+		return Qnil;
+
 	val = StringValuePtr(argv[0]);
 	if( !this->dec_func ){
 		rb_raise(rb_eRuntimeError, "no decoder function defined");
@@ -406,6 +417,14 @@ init_pg_coder()
 	/* Document-class: PG::Coder < Object
 	 *
 	 * This is the base class for all type cast encoder and decoder classes.
+	 *
+	 * It can be used for implicit type casts by a PG::TypeMap or to
+	 * convert single values to/from their string representation by #encode
+	 * and #decode.
+	 *
+	 * Ruby +nil+ values are not handled by encoders, but are always transmitted
+	 * as SQL +NULL+ value. Vice versa SQL +NULL+ values are not handled by decoders,
+	 * but are always returned as a +nil+ value.
 	 */
 	rb_cPG_Coder = rb_define_class_under( rb_mPG, "Coder", rb_cObject );
 	rb_define_alloc_func( rb_cPG_Coder, pg_coder_allocate );

data/ext/pg_text_encoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_encoder.c - PG::TextEncoder module
- * $Id: pg_text_encoder.c,v ac23631c96d9 2014/10/14 11:50:21 lars $
+ * $Id: pg_text_encoder.c,v a4725dfca9e4 2014/10/15 19:50:56 lars $
  *
  */
 
@@ -46,6 +46,7 @@
 VALUE rb_mPG_TextEncoder;
 static ID s_id_encode;
 static ID s_id_to_i;
+static VALUE hash_false_values;
 
 
 VALUE
@@ -66,7 +67,39 @@ pg_obj_to_i( VALUE value )
  *
  * This is the encoder class for the PostgreSQL bool type.
  *
+ * Ruby values false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off' and 'OFF'
+ * are encoded as SQL +FALSE+ value. nil is sent as SQL +NULL+.
+ * Any other values are encoded as SQL +TRUE+ .
+ *
  */
+static int
+pg_text_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	if(out){
+		switch( TYPE(value) ){
+			case T_FALSE:
+				*out = 'f';
+				break;
+			case T_FIXNUM:
+			case T_BIGNUM:
+				if( NUM2LONG(value) == 0 ){
+					*out = 'f';
+				} else {
+					*out = 't';
+				}
+				break;
+			case T_STRING:
+				if( rb_hash_lookup(hash_false_values, value) == Qtrue ){
+					*out = 'f';
+					break;
+				}
+				/* fall through */
+			default:
+				*out = 't';
+		}
+	}
+	return 1;
+}
 
 
 /*
@@ -213,34 +246,6 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 	}
 }
 
-/*
- * Case-independent comparison of two not-necessarily-null-terminated strings.
- * At most n bytes will be examined from each string.
- */
-static int
-pg_strncasecmp(const char *s1, const char *s2, size_t n)
-{
-	while (n-- > 0)
-	{
-		unsigned char ch1 = (unsigned char) *s1++;
-		unsigned char ch2 = (unsigned char) *s2++;
-
-		if (ch1 != ch2){
-			if (ch1 >= 'A' && ch1 <= 'Z')
-				ch1 += 'a' - 'A';
-
-			if (ch2 >= 'A' && ch2 <= 'Z')
-				ch2 += 'a' - 'A';
-
-			if (ch1 != ch2)
-				return (int) ch1 - (int) ch2;
-		}
-		if (ch1 == 0)
-			break;
-	}
-	return 0;
-}
-
 typedef int (*t_quote_func)( void *_this, char *p_in, int strlen, char *p_out );
 
 static int
@@ -387,19 +392,27 @@ write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE st
  * All values are encoded according to the #elements_type
  * accessor. Sub-arrays are encoded recursively.
  *
+ * This encoder expects an Array of values or sub-arrays as input.
+ * Other values are passed through as text without interpretation.
+ *
  */
 static int
 pg_text_enc_array(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 {
 	char *end_ptr;
 	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
-	*intermediate = rb_str_new(NULL, 0);
 
-	end_ptr = write_array(this, value, RSTRING_PTR(*intermediate), *intermediate, this->needs_quotation);
+	if( TYPE(value) == T_ARRAY){
+		*intermediate = rb_str_new(NULL, 0);
 
-	rb_str_set_len( *intermediate, end_ptr - RSTRING_PTR(*intermediate) );
+		end_ptr = write_array(this, value, RSTRING_PTR(*intermediate), *intermediate, this->needs_quotation);
 
-	return -1;
+		rb_str_set_len( *intermediate, end_ptr - RSTRING_PTR(*intermediate) );
+
+		return -1;
+	} else {
+		return pg_coder_enc_to_s( conv, value, out, intermediate );
+	}
 }
 
 static int
@@ -584,12 +597,22 @@ init_pg_text_encoder()
 	s_id_encode = rb_intern("encode");
 	s_id_to_i = rb_intern("to_i");
 
+	hash_false_values = rb_hash_new();
+	rb_gc_register_address( &hash_false_values );
+	rb_hash_aset( hash_false_values, rb_str_new2( "0" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "f" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "F" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "false" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "FALSE" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "off" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "OFF" ), Qtrue );
+
 	/* This module encapsulates all encoder classes with text output format */
 	rb_mPG_TextEncoder = rb_define_module_under( rb_mPG, "TextEncoder" );
 
 	/* Make RDoc aware of the encoder classes... */
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Boolean", rb_cPG_SimpleEncoder ); */
-	pg_define_coder( "Boolean", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+	pg_define_coder( "Boolean", pg_text_enc_boolean, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Integer", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "Integer", pg_text_enc_integer, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Float", rb_cPG_SimpleEncoder ); */

data/ext/util.c

@@ -1,6 +1,6 @@
 /*
  * util.c - Utils for ruby-pg
- * $Id: util.c,v c8d7c26dd595 2014/10/12 17:08:46 lars $
+ * $Id: util.c,v 117fb5c5eed7 2014/10/15 18:36:39 lars $
  *
  */
 
@@ -119,3 +119,31 @@ base64_decode( char *out, char *in, unsigned int len)
 	return (char*)out_ptr - out;
 }
 
+/*
+ * Case-independent comparison of two not-necessarily-null-terminated strings.
+ * At most n bytes will be examined from each string.
+ */
+int
+pg_strncasecmp(const char *s1, const char *s2, size_t n)
+{
+	while (n-- > 0)
+	{
+		unsigned char ch1 = (unsigned char) *s1++;
+		unsigned char ch2 = (unsigned char) *s2++;
+
+		if (ch1 != ch2){
+			if (ch1 >= 'A' && ch1 <= 'Z')
+				ch1 += 'a' - 'A';
+
+			if (ch2 >= 'A' && ch2 <= 'Z')
+				ch2 += 'a' - 'A';
+
+			if (ch1 != ch2)
+				return (int) ch1 - (int) ch2;
+		}
+		if (ch1 == 0)
+			break;
+	}
+	return 0;
+}
+

data/ext/util.h

@@ -60,4 +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);
+
 #endif /* end __utils_h */

data/spec/pg/type_spec.rb

@@ -7,6 +7,8 @@ require 'pg'
 describe "PG::Type derivations" do
 	let!(:textenc_int) { PG::TextEncoder::Integer.new name: 'Integer', oid: 23 }
 	let!(:textdec_int) { PG::TextDecoder::Integer.new name: 'Integer', oid: 23 }
+	let!(:textenc_boolean) { PG::TextEncoder::Boolean.new }
+	let!(:textdec_boolean) { PG::TextDecoder::Boolean.new }
 	let!(:textenc_float) { PG::TextEncoder::Float.new }
 	let!(:textdec_float) { PG::TextDecoder::Float.new }
 	let!(:textenc_string) { PG::TextEncoder::String.new }
@@ -88,6 +90,11 @@ describe "PG::Type derivations" do
 				expect{ textdec_int.decode(2, 3, 4) }.to raise_error(TypeError)
 				expect( intdec_incrementer.decode(2, 3, 4) ).to eq( 3 )
 			end
+
+			it "should pass through nil values" do
+				expect( textdec_string.encode( nil )).to be_nil
+				expect( textdec_int.encode( nil )).to be_nil
+			end
 		end
 
 		describe '#encode' do
@@ -130,6 +137,18 @@ 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" )
+				end
+			end
+
 			it "should encode special floats equally to Float#to_s" do
 				expect( textenc_float.encode(Float::INFINITY) ).to eq( Float::INFINITY.to_s )
 				expect( textenc_float.encode(-Float::INFINITY) ).to eq( (-Float::INFINITY).to_s )
@@ -143,6 +162,11 @@ describe "PG::Type derivations" do
 			it "should return when ruby encoder returns non string values" do
 				expect( intenc_incrementer_with_int_result.encode(3) ).to eq( 4 )
 			end
+
+			it "should pass through nil values" do
+				expect( textenc_string.encode( nil )).to be_nil
+				expect( textenc_int.encode( nil )).to be_nil
+			end
 		end
 
 		it "should be possible to marshal encoders" do
@@ -377,6 +401,11 @@ describe "PG::Type derivations" do
 					end
 				end
 
+				it "should pass through non Array inputs" do
+					expect( textenc_float_array.encode("text") ).to eq( "text" )
+					expect( textenc_float_array.encode(1234) ).to eq( "1234" )
+				end
+
 				context 'identifier quotation' do
 					it 'should quote and escape identifier' do
 						quoted_type = PG::TextEncoder::Identifier.new elements_type: textenc_string

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg
 version: !ruby/object:Gem::Version
-  version: 0.18.0.pre20141017155815
+  version: 0.18.0.pre20141017160319
 platform: ruby
 authors:
 - Michael Granger