pg 0.17.1 → 0.18.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. checksums.yaml +4 -4
  2. checksums.yaml.gz.sig +0 -0
  3. data/ChangeLog +2407 -2
  4. data/History.rdoc +68 -0
  5. data/Manifest.txt +29 -1
  6. data/README-Windows.rdoc +15 -26
  7. data/README.rdoc +52 -2
  8. data/Rakefile +56 -18
  9. data/Rakefile.cross +77 -49
  10. data/ext/extconf.rb +33 -26
  11. data/ext/pg.c +142 -21
  12. data/ext/pg.h +242 -6
  13. data/ext/pg_binary_decoder.c +162 -0
  14. data/ext/pg_binary_encoder.c +162 -0
  15. data/ext/pg_coder.c +479 -0
  16. data/ext/pg_connection.c +858 -553
  17. data/ext/pg_copy_coder.c +561 -0
  18. data/ext/pg_errors.c +6 -0
  19. data/ext/pg_result.c +479 -128
  20. data/ext/pg_text_decoder.c +421 -0
  21. data/ext/pg_text_encoder.c +663 -0
  22. data/ext/pg_type_map.c +159 -0
  23. data/ext/pg_type_map_all_strings.c +116 -0
  24. data/ext/pg_type_map_by_class.c +239 -0
  25. data/ext/pg_type_map_by_column.c +312 -0
  26. data/ext/pg_type_map_by_mri_type.c +284 -0
  27. data/ext/pg_type_map_by_oid.c +355 -0
  28. data/ext/pg_type_map_in_ruby.c +299 -0
  29. data/ext/util.c +149 -0
  30. data/ext/util.h +65 -0
  31. data/lib/pg/basic_type_mapping.rb +399 -0
  32. data/lib/pg/coder.rb +83 -0
  33. data/lib/pg/connection.rb +81 -29
  34. data/lib/pg/result.rb +13 -3
  35. data/lib/pg/text_decoder.rb +44 -0
  36. data/lib/pg/text_encoder.rb +27 -0
  37. data/lib/pg/type_map_by_column.rb +15 -0
  38. data/lib/pg.rb +12 -2
  39. data/spec/{lib/helpers.rb → helpers.rb} +101 -39
  40. data/spec/pg/basic_type_mapping_spec.rb +251 -0
  41. data/spec/pg/connection_spec.rb +516 -218
  42. data/spec/pg/result_spec.rb +216 -112
  43. data/spec/pg/type_map_by_class_spec.rb +138 -0
  44. data/spec/pg/type_map_by_column_spec.rb +222 -0
  45. data/spec/pg/type_map_by_mri_type_spec.rb +136 -0
  46. data/spec/pg/type_map_by_oid_spec.rb +149 -0
  47. data/spec/pg/type_map_in_ruby_spec.rb +164 -0
  48. data/spec/pg/type_map_spec.rb +22 -0
  49. data/spec/pg/type_spec.rb +697 -0
  50. data/spec/pg_spec.rb +24 -18
  51. data.tar.gz.sig +0 -0
  52. metadata +111 -45
  53. metadata.gz.sig +0 -0
@@ -0,0 +1,421 @@
1
+ /*
2
+ * pg_text_decoder.c - PG::TextDecoder module
3
+ * $Id: pg_text_decoder.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
4
+ *
5
+ */
6
+
7
+ /*
8
+ *
9
+ * Type casts for decoding PostgreSQL string representations to Ruby objects.
10
+ *
11
+ * Decoder classes are defined with pg_define_coder(). This creates a new coder class and
12
+ * assigns a decoder function.
13
+ *
14
+ * Signature of all type cast decoders is:
15
+ * VALUE decoder_function(t_pg_coder *this, char *val, int len, int tuple, int field, int enc_idx)
16
+ *
17
+ * Params:
18
+ * this - The data part of the coder object that belongs to the decoder function.
19
+ * val, len - The text or binary data to decode. The caller ensures, that the data is
20
+ * zero terminated ( that is val[len] = 0 ). The memory should be used read
21
+ * only by the callee.
22
+ * tuple - Row of the value within the result set.
23
+ * field - Column of the value within the result set.
24
+ * enc_idx - Index of the Encoding that any output String should get assigned.
25
+ *
26
+ * Returns:
27
+ * The type casted Ruby object.
28
+ *
29
+ */
30
+
31
+ #include "pg.h"
32
+ #include "util.h"
33
+ #ifdef HAVE_INTTYPES_H
34
+ #include <inttypes.h>
35
+ #endif
36
+
37
+ VALUE rb_mPG_TextDecoder;
38
+ static ID s_id_decode;
39
+
40
+
41
+ /*
42
+ * Document-class: PG::TextDecoder::Boolean < PG::SimpleDecoder
43
+ *
44
+ * This is a decoder class for conversion of PostgreSQL boolean type
45
+ * to Ruby true or false values.
46
+ *
47
+ */
48
+ static VALUE
49
+ pg_text_dec_boolean(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
50
+ {
51
+ if (len < 1) {
52
+ rb_raise( rb_eTypeError, "wrong data for text boolean converter in tuple %d field %d", tuple, field);
53
+ }
54
+ return *val == 't' ? Qtrue : Qfalse;
55
+ }
56
+
57
+ /*
58
+ * Document-class: PG::TextDecoder::String < PG::SimpleDecoder
59
+ *
60
+ * This is a decoder class for conversion of PostgreSQL text output to
61
+ * to Ruby String object. The output value will have the character encoding
62
+ * set with PG::Connection#internal_encoding= .
63
+ *
64
+ */
65
+ VALUE
66
+ pg_text_dec_string(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
67
+ {
68
+ VALUE ret = rb_tainted_str_new( val, len );
69
+ PG_ENCODING_SET_NOCHECK( ret, enc_idx );
70
+ return ret;
71
+ }
72
+
73
+ /*
74
+ * Document-class: PG::TextDecoder::Integer < PG::SimpleDecoder
75
+ *
76
+ * This is a decoder class for conversion of PostgreSQL integer types
77
+ * to Ruby Integer objects.
78
+ *
79
+ */
80
+ static VALUE
81
+ pg_text_dec_integer(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
82
+ {
83
+ long i;
84
+ int max_len;
85
+
86
+ if( sizeof(i) >= 8 && FIXNUM_MAX >= 1000000000000000000LL ){
87
+ /* 64 bit system can safely handle all numbers up to 18 digits as Fixnum */
88
+ max_len = 18;
89
+ } else if( sizeof(i) >= 4 && FIXNUM_MAX >= 1000000000LL ){
90
+ /* 32 bit system can safely handle all numbers up to 9 digits as Fixnum */
91
+ max_len = 9;
92
+ } else {
93
+ /* unknown -> don't use fast path for int conversion */
94
+ max_len = 0;
95
+ }
96
+
97
+ if( len <= max_len ){
98
+ /* rb_cstr2inum() seems to be slow, so we do the int conversion by hand.
99
+ * This proved to be 40% faster by the following benchmark:
100
+ *
101
+ * conn.type_mapping_for_results = PG::BasicTypeMapForResults.new conn
102
+ * Benchmark.measure do
103
+ * conn.exec("select generate_series(1,1000000)").values }
104
+ * end
105
+ */
106
+ char *val_pos = val;
107
+ char digit = *val_pos;
108
+ int neg;
109
+ int error = 0;
110
+
111
+ if( digit=='-' ){
112
+ neg = 1;
113
+ i = 0;
114
+ }else if( digit>='0' && digit<='9' ){
115
+ neg = 0;
116
+ i = digit - '0';
117
+ } else {
118
+ error = 1;
119
+ }
120
+
121
+ while (!error && (digit=*++val_pos)) {
122
+ if( digit>='0' && digit<='9' ){
123
+ i = i * 10 + (digit - '0');
124
+ } else {
125
+ error = 1;
126
+ }
127
+ }
128
+
129
+ if( !error ){
130
+ return LONG2FIX(neg ? -i : i);
131
+ }
132
+ }
133
+ /* Fallback to ruby method if number too big or unrecognized. */
134
+ return rb_cstr2inum(val, 10);
135
+ }
136
+
137
+ /*
138
+ * Document-class: PG::TextDecoder::Float < PG::SimpleDecoder
139
+ *
140
+ * This is a decoder class for conversion of PostgreSQL float4 and float8 types
141
+ * to Ruby Float objects.
142
+ *
143
+ */
144
+ static VALUE
145
+ pg_text_dec_float(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
146
+ {
147
+ return rb_float_new(strtod(val, NULL));
148
+ }
149
+
150
+ /*
151
+ * Document-class: PG::TextDecoder::Bytea < PG::SimpleDecoder
152
+ *
153
+ * This is a decoder class for conversion of PostgreSQL bytea type
154
+ * to binary String objects.
155
+ *
156
+ */
157
+ static VALUE
158
+ pg_text_dec_bytea(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
159
+ {
160
+ unsigned char *to;
161
+ size_t to_len;
162
+ VALUE ret;
163
+
164
+ to = PQunescapeBytea( (unsigned char *)val, &to_len);
165
+
166
+ ret = rb_tainted_str_new((char*)to, to_len);
167
+ PQfreemem(to);
168
+
169
+ return ret;
170
+ }
171
+
172
+ /*
173
+ * Array parser functions are thankfully borrowed from here:
174
+ * https://github.com/dockyard/pg_array_parser
175
+ */
176
+ static VALUE
177
+ read_array(t_pg_composite_coder *this, int *index, char *c_pg_array_string, int array_string_length, char *word, int enc_idx, int tuple, int field, t_pg_coder_dec_func dec_func)
178
+ {
179
+ /* Return value: array */
180
+ VALUE array;
181
+ int word_index = 0;
182
+
183
+ /* The current character in the input string. */
184
+ char c;
185
+
186
+ /* 0: Currently outside a quoted string, current word never quoted
187
+ * 1: Currently inside a quoted string
188
+ * -1: Currently outside a quoted string, current word previously quoted */
189
+ int openQuote = 0;
190
+
191
+ /* Inside quoted input means the next character should be treated literally,
192
+ * instead of being treated as a metacharacter.
193
+ * Outside of quoted input, means that the word shouldn't be pushed to the array,
194
+ * used when the last entry was a subarray (which adds to the array itself). */
195
+ int escapeNext = 0;
196
+
197
+ array = rb_ary_new();
198
+
199
+ /* Special case the empty array, so it doesn't need to be handled manually inside
200
+ * the loop. */
201
+ if(((*index) < array_string_length) && c_pg_array_string[(*index)] == '}')
202
+ {
203
+ return array;
204
+ }
205
+
206
+ for(;(*index) < array_string_length; ++(*index))
207
+ {
208
+ c = c_pg_array_string[*index];
209
+ if(openQuote < 1)
210
+ {
211
+ if(c == this->delimiter || c == '}')
212
+ {
213
+ if(!escapeNext)
214
+ {
215
+ if(openQuote == 0 && word_index == 4 && !strncmp(word, "NULL", word_index))
216
+ {
217
+ rb_ary_push(array, Qnil);
218
+ }
219
+ else
220
+ {
221
+ VALUE val;
222
+ word[word_index] = 0;
223
+ val = dec_func(this->elem, word, word_index, tuple, field, enc_idx);
224
+ rb_ary_push(array, val);
225
+ }
226
+ }
227
+ if(c == '}')
228
+ {
229
+ return array;
230
+ }
231
+ escapeNext = 0;
232
+ openQuote = 0;
233
+ word_index = 0;
234
+ }
235
+ else if(c == '"')
236
+ {
237
+ openQuote = 1;
238
+ }
239
+ else if(c == '{')
240
+ {
241
+ (*index)++;
242
+ rb_ary_push(array, read_array(this, index, c_pg_array_string, array_string_length, word, enc_idx, tuple, field, dec_func));
243
+ escapeNext = 1;
244
+ }
245
+ else
246
+ {
247
+ word[word_index] = c;
248
+ word_index++;
249
+ }
250
+ }
251
+ else if (escapeNext) {
252
+ word[word_index] = c;
253
+ word_index++;
254
+ escapeNext = 0;
255
+ }
256
+ else if (c == '\\')
257
+ {
258
+ escapeNext = 1;
259
+ }
260
+ else if (c == '"')
261
+ {
262
+ openQuote = -1;
263
+ }
264
+ else
265
+ {
266
+ word[word_index] = c;
267
+ word_index++;
268
+ }
269
+ }
270
+
271
+ return array;
272
+ }
273
+
274
+ /*
275
+ * Document-class: PG::TextDecoder::Array < PG::CompositeDecoder
276
+ *
277
+ * This is the decoder class for PostgreSQL array types.
278
+ *
279
+ * All values are decoded according to the #elements_type
280
+ * accessor. Sub-arrays are decoded recursively.
281
+ *
282
+ */
283
+ static VALUE
284
+ pg_text_dec_array(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
285
+ {
286
+ t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
287
+ t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, 0);
288
+ /* create a buffer of the same length, as that will be the worst case */
289
+ char *word = xmalloc(len + 1);
290
+ int index = 1;
291
+
292
+ VALUE return_value = read_array(this, &index, val, len, word, enc_idx, tuple, field, dec_func);
293
+ free(word);
294
+ return return_value;
295
+ }
296
+
297
+ /*
298
+ * Document-class: PG::TextDecoder::Identifier < PG::SimpleDecoder
299
+ *
300
+ * This is the decoder class for PostgreSQL identifiers.
301
+ *
302
+ * Returns an Array of identifiers:
303
+ * PG::TextDecoder::Identifier.new.decode('schema."table"."column"')
304
+ * => ["schema", "table", "column"]
305
+ *
306
+ */
307
+ static VALUE
308
+ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
309
+ {
310
+ /* Return value: array */
311
+ VALUE array;
312
+ VALUE elem;
313
+ int word_index = 0;
314
+ int index;
315
+ /* Use a buffer of the same length, as that will be the worst case */
316
+ PG_VARIABLE_LENGTH_ARRAY(char, word, len + 1, NAMEDATALEN)
317
+
318
+ /* The current character in the input string. */
319
+ char c;
320
+
321
+ /* 0: Currently outside a quoted string
322
+ * 1: Currently inside a quoted string, last char was a quote
323
+ * 2: Currently inside a quoted string, last char was no quote */
324
+ int openQuote = 0;
325
+
326
+ array = rb_ary_new();
327
+
328
+ for(index = 0; index < len; ++index) {
329
+ c = val[index];
330
+ if(c == '.' && openQuote < 2 ) {
331
+ word[word_index] = 0;
332
+
333
+ elem = pg_text_dec_string(conv, word, word_index, tuple, field, enc_idx);
334
+ rb_ary_push(array, elem);
335
+
336
+ openQuote = 0;
337
+ word_index = 0;
338
+ } else if(c == '"') {
339
+ if (openQuote == 1) {
340
+ word[word_index] = c;
341
+ word_index++;
342
+ openQuote = 2;
343
+ } else if (openQuote == 2){
344
+ openQuote = 1;
345
+ } else {
346
+ openQuote = 2;
347
+ }
348
+ } else {
349
+ word[word_index] = c;
350
+ word_index++;
351
+ }
352
+ }
353
+
354
+ word[word_index] = 0;
355
+ elem = pg_text_dec_string(conv, word, word_index, tuple, field, enc_idx);
356
+ rb_ary_push(array, elem);
357
+
358
+ return array;
359
+ }
360
+
361
+ /*
362
+ * Document-class: PG::TextDecoder::FromBase64 < PG::CompositeDecoder
363
+ *
364
+ * This is a decoder class for conversion of base64 encoded data
365
+ * to it's binary representation. It outputs a binary Ruby String
366
+ * or some other Ruby object, if a #elements_type decoder was defined.
367
+ *
368
+ */
369
+ static VALUE
370
+ pg_text_dec_from_base64(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
371
+ {
372
+ t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
373
+ t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, this->comp.format);
374
+ int decoded_len;
375
+ /* create a buffer of the expected decoded length */
376
+ VALUE out_value = rb_tainted_str_new(NULL, BASE64_DECODED_SIZE(len));
377
+
378
+ decoded_len = base64_decode( RSTRING_PTR(out_value), val, len );
379
+ rb_str_set_len(out_value, decoded_len);
380
+
381
+ /* Is it a pure String conversion? Then we can directly send out_value to the user. */
382
+ if( this->comp.format == 0 && dec_func == pg_text_dec_string ){
383
+ PG_ENCODING_SET_NOCHECK( out_value, enc_idx );
384
+ return out_value;
385
+ }
386
+ if( this->comp.format == 1 && dec_func == pg_bin_dec_bytea ){
387
+ PG_ENCODING_SET_NOCHECK( out_value, rb_ascii8bit_encindex() );
388
+ return out_value;
389
+ }
390
+ out_value = dec_func(this->elem, RSTRING_PTR(out_value), decoded_len, tuple, field, enc_idx);
391
+
392
+ return out_value;
393
+ }
394
+
395
+ void
396
+ init_pg_text_decoder()
397
+ {
398
+ s_id_decode = rb_intern("decode");
399
+
400
+ /* This module encapsulates all decoder classes with text input format */
401
+ rb_mPG_TextDecoder = rb_define_module_under( rb_mPG, "TextDecoder" );
402
+
403
+ /* Make RDoc aware of the decoder classes... */
404
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Boolean", rb_cPG_SimpleDecoder ); */
405
+ pg_define_coder( "Boolean", pg_text_dec_boolean, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
406
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Integer", rb_cPG_SimpleDecoder ); */
407
+ pg_define_coder( "Integer", pg_text_dec_integer, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
408
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Float", rb_cPG_SimpleDecoder ); */
409
+ pg_define_coder( "Float", pg_text_dec_float, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
410
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "String", rb_cPG_SimpleDecoder ); */
411
+ pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
412
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Bytea", rb_cPG_SimpleDecoder ); */
413
+ pg_define_coder( "Bytea", pg_text_dec_bytea, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
414
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Identifier", rb_cPG_SimpleDecoder ); */
415
+ pg_define_coder( "Identifier", pg_text_dec_identifier, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
416
+
417
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Array", rb_cPG_CompositeDecoder ); */
418
+ pg_define_coder( "Array", pg_text_dec_array, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
419
+ /* dummy = rb_define_class_under( rb_mPG_TextDecoder, "FromBase64", rb_cPG_CompositeDecoder ); */
420
+ pg_define_coder( "FromBase64", pg_text_dec_from_base64, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
421
+ }