projects / m6w6 / ext-pq / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
release 2.1.6
[m6w6/ext-pq] / src / php_pqres.c
1 /*
2 +--------------------------------------------------------------------+
3 | PECL :: pq |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2013, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 #ifdef HAVE_CONFIG_H
14 # include "config.h"
15 #endif
16
17 #include <php.h>
18
19 #include <ext/spl/spl_iterators.h>
20 #if PHP_PQ_HAVE_PHP_JSON_H
21 #include <php_json.h> /* we've added the include directory to INCLUDES */
22 #endif
23
24 #include <libpq-events.h>
25
26 #include "php_pq.h"
27 #include "php_pq_misc.h"
28 #include "php_pq_object.h"
29 #include "php_pqexc.h"
30 #include "php_pqres.h"
31 #undef PHP_PQ_TYPE
32 #include "php_pq_type.h"
33
34 zend_class_entry *php_pqres_class_entry;
35 static zend_object_handlers php_pqres_object_handlers;
36 static HashTable php_pqres_object_prophandlers;
37 static zend_object_iterator_funcs php_pqres_iterator_funcs;
38
39 static inline zend_object_iterator *php_pqres_iterator_init_ex(zend_class_entry *ce, zval *object, int by_ref)
40 {
41 php_pqres_iterator_t *iter;
42 zval tmp, *zfetch_type;
43
44 iter = ecalloc(1, sizeof(*iter));
45 iter->zi.funcs = &php_pqres_iterator_funcs;
46 ZVAL_COPY_VALUE(&iter->zi.data, object);
47
48 zfetch_type = zend_read_property(ce, object, ZEND_STRL("fetchType"), 0, &tmp);
49 iter->fetch_type = zval_get_long(zfetch_type);
50 #if DBG_GC
51 fprintf(stderr, "INIT iter(#%d) %p res(#%d) %p\n", iter->zi.std.handle, iter, Z_OBJ_HANDLE_P(object), PHP_PQ_OBJ(object, NULL));
52 #endif
53 return (zend_object_iterator *) iter;
54 }
55
56 static zend_object_iterator *php_pqres_iterator_init(zend_class_entry *ce, zval *object, int by_ref)
57 {
58 zend_object_iterator *iter = php_pqres_iterator_init_ex(ce, object, by_ref);
59
60 zend_iterator_init(iter);
61 Z_ADDREF_P(object);
62
63 return iter;
64 }
65 static void php_pqres_internal_iterator_init(zval *zobj)
66 {
67 php_pqres_object_t *obj = PHP_PQ_OBJ(zobj, NULL);
68
69 obj->intern->iter = (php_pqres_iterator_t *) php_pqres_iterator_init_ex(Z_OBJCE_P(zobj), zobj, 0);
70 obj->intern->iter->zi.funcs->rewind((zend_object_iterator *) obj->intern->iter);
71
72 }
73
74 static inline void php_pqres_iterator_dtor_ex(zend_object_iterator *i)
75 {
76 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
77
78 #if DBG_GC
79 fprintf(stderr, "FREE iter(#%d) rc=%d %p\n", iter->zi.std.handle, GC_REFCOUNT(&iter->zi.std), iter);
80 #endif
81 if (!Z_ISUNDEF(iter->current_val)) {
82 zval_ptr_dtor(&iter->current_val);
83 ZVAL_UNDEF(&iter->current_val);
84 }
85 }
86
87 static void php_pqres_iterator_dtor(zend_object_iterator *i)
88 {
89 php_pqres_iterator_dtor_ex(i);
90 zval_ptr_dtor(&i->data);
91 }
92
93 static void php_pqres_internal_iterator_dtor(php_pqres_object_t *obj)
94 {
95 if (obj->intern && obj->intern->iter) {
96 php_pqres_iterator_dtor_ex((zend_object_iterator *) obj->intern->iter);
97 efree(obj->intern->iter);
98 obj->intern->iter = NULL;
99 }
100 }
101
102 static ZEND_RESULT_CODE php_pqres_iterator_valid(zend_object_iterator *i)
103 {
104 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
105 php_pqres_object_t *obj = PHP_PQ_OBJ(&i->data, NULL);
106
107 switch (PQresultStatus(obj->intern->res)) {
108 case PGRES_TUPLES_OK:
109 #ifdef HAVE_PGRES_SINGLE_TUPLE
110 case PGRES_SINGLE_TUPLE:
111 #endif
112 if (PQntuples(obj->intern->res) <= iter->index) {
113 return FAILURE;
114 }
115 break;
116 default:
117 return FAILURE;
118 }
119
120 return SUCCESS;
121 }
122
123 #define PHP_PQRES_JSON_OPTIONS(res) \
124 (php_pqres_fetch_type(res) != PHP_PQRES_FETCH_OBJECT ? PHP_JSON_OBJECT_AS_ARRAY:0)
125
126 zval *php_pqres_typed_zval(php_pqres_t *res, Oid typ, zval *zv)
127 {
128 zval *zconv;
129 HashTable *ht;
130 zend_string *str;
131
132 if ((zconv = zend_hash_index_find(&res->converters, typ))) {
133 zval ztype, rv;
134
135 ZVAL_NULL(&rv);
136 ZVAL_LONG(&ztype, typ);
137 zend_call_method_with_2_params(zconv, NULL, NULL, "convertfromstring", &rv, zv, &ztype);
138
139 zval_ptr_dtor(zv);
140 ZVAL_ZVAL(zv, &rv, 0, 0);
141
142 return zv;
143 }
144
145 str = zval_get_string(zv);
146 zval_ptr_dtor(zv);
147
148 switch (typ) {
149 case PHP_PQ_OID_BOOL:
150 if (!(res->auto_convert & PHP_PQRES_CONV_BOOL)) {
151 goto noconversion;
152 }
153 ZVAL_BOOL(zv, *str->val == 't');
154 break;
155
156 case PHP_PQ_OID_INT8:
157 case PHP_PQ_OID_TID:
158 case PHP_PQ_OID_INT4:
159 case PHP_PQ_OID_INT2:
160 case PHP_PQ_OID_XID:
161 case PHP_PQ_OID_OID:
162 if (!(res->auto_convert & PHP_PQRES_CONV_INT)) {
163 goto noconversion;
164 }
165 {
166 zend_long lval;
167 double dval;
168
169 switch (is_numeric_str_function(str, &lval, &dval)) {
170 case IS_LONG:
171 ZVAL_LONG(zv, lval);
172 break;
173 case IS_DOUBLE:
174 ZVAL_DOUBLE(zv, dval);
175 break;
176 default:
177 goto noconversion;
178 }
179 }
180 break;
181
182 case PHP_PQ_OID_FLOAT4:
183 case PHP_PQ_OID_FLOAT8:
184 if (!(res->auto_convert & PHP_PQRES_CONV_FLOAT)) {
185 goto noconversion;
186 }
187 ZVAL_DOUBLE(zv, zend_strtod(str->val, NULL));
188 break;
189
190 case PHP_PQ_OID_DATE:
191 if (!(res->auto_convert & PHP_PQRES_CONV_DATETIME)) {
192 goto noconversion;
193 }
194 php_pqdt_from_string(zv, NULL, str->val, str->len, "Y-m-d", NULL);
195 break;
196 #ifdef PHP_PQ_OID_ABSTIME
197 case PHP_PQ_OID_ABSTIME:
198 if (!(res->auto_convert & PHP_PQRES_CONV_DATETIME)) {
199 goto noconversion;
200 }
201 php_pqdt_from_string(zv, NULL, str->val, str->len, "Y-m-d H:i:s", NULL);
202 break;
203 #endif
204 case PHP_PQ_OID_TIMESTAMP:
205 if (!(res->auto_convert & PHP_PQRES_CONV_DATETIME)) {
206 goto noconversion;
207 }
208 php_pqdt_from_string(zv, NULL, str->val, str->len, "Y-m-d H:i:s.u", NULL);
209 break;
210
211 case PHP_PQ_OID_TIMESTAMPTZ:
212 if (!(res->auto_convert & PHP_PQRES_CONV_DATETIME)) {
213 goto noconversion;
214 }
215 php_pqdt_from_string(zv, NULL, str->val, str->len, "Y-m-d H:i:s.uO", NULL);
216 break;
217
218 #if PHP_PQ_HAVE_PHP_JSON_H && defined(PHP_PQ_OID_JSON)
219 # ifdef PHP_PQ_OID_JSONB
220 case PHP_PQ_OID_JSONB:
221 # endif
222 case PHP_PQ_OID_JSON:
223 if (!(res->auto_convert & PHP_PQRES_CONV_JSON)) {
224 goto noconversion;
225 }
226 php_json_decode_ex(zv, str->val, str->len, PHP_PQRES_JSON_OPTIONS(res), 512 /* PHP_JSON_DEFAULT_DEPTH */);
227 break;
228 #endif
229
230 default:
231 if (!(res->auto_convert & PHP_PQRES_CONV_ARRAY)) {
232 goto noconversion;
233 }
234 if (PHP_PQ_TYPE_IS_ARRAY(typ) && (ht = php_pq_parse_array(res, str->val, str->len, PHP_PQ_TYPE_OF_ARRAY(typ)))) {
235 ZVAL_ARR(zv, ht);
236 } else {
237 goto noconversion;
238 }
239 break;
240 }
241
242 zend_string_release(str);
243 return zv;
244
245 noconversion:
246 ZVAL_STR(zv, str);
247 return zv;
248 }
249
250 static inline zval *php_pqres_get_col(php_pqres_t *r, unsigned row, unsigned col, zval *zv)
251 {
252 if (PQgetisnull(r->res, row, col)) {
253 ZVAL_NULL(zv);
254 } else {
255 ZVAL_STRINGL(zv, PQgetvalue(r->res, row, col), PQgetlength(r->res, row, col));
256 zv = php_pqres_typed_zval(r, PQftype(r->res, col), zv);
257 }
258
259 return zv;
260 }
261
262 static inline void php_pqres_add_col_to_zval(php_pqres_t *r, unsigned row, unsigned col, php_pqres_fetch_t fetch_type, zval *data)
263 {
264 if (PQgetisnull(r->res, row, col)) {
265 switch (fetch_type) {
266 case PHP_PQRES_FETCH_OBJECT:
267 add_property_null(data, PQfname(r->res, col));
268 break;
269
270 case PHP_PQRES_FETCH_ASSOC:
271 add_assoc_null(data, PQfname(r->res, col));
272 break;
273
274 case PHP_PQRES_FETCH_ARRAY:
275 add_index_null(data, col);
276 break;
277 }
278 } else {
279 zval zv;
280
281 ZVAL_STRINGL(&zv, PQgetvalue(r->res, row, col), PQgetlength(r->res, row, col));
282 php_pqres_typed_zval(r, PQftype(r->res, col), &zv);
283
284 switch (fetch_type) {
285 case PHP_PQRES_FETCH_OBJECT:
286 add_property_zval(data, PQfname(r->res, col), &zv);
287 zval_ptr_dtor(&zv);
288 break;
289
290 case PHP_PQRES_FETCH_ASSOC:
291 add_assoc_zval(data, PQfname(r->res, col), &zv);
292 break;
293
294 case PHP_PQRES_FETCH_ARRAY:
295 add_index_zval(data, col, &zv);
296 break;
297 }
298 }
299 }
300
301 zval *php_pqres_row_to_zval(PGresult *res, unsigned row, php_pqres_fetch_t fetch_type, zval *data)
302 {
303 int c, cols = PQnfields(res);
304 php_pqres_object_t *res_obj = PQresultInstanceData(res, php_pqconn_event);
305
306 if (Z_TYPE_P(data) != IS_OBJECT && Z_TYPE_P(data) != IS_ARRAY) {
307 if (PHP_PQRES_FETCH_OBJECT == fetch_type) {
308 object_init(data);
309 } else {
310 array_init_size(data, cols);
311 }
312 }
313
314 if (PQntuples(res) > row) {
315 for (c = 0; c < cols; ++c) {
316 php_pqres_add_col_to_zval(res_obj->intern, row, c, fetch_type, data);
317 }
318 }
319
320 return data;
321 }
322
323 static zval *php_pqres_iterator_current(zend_object_iterator *i)
324 {
325 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
326 php_pqres_object_t *obj = PHP_PQ_OBJ(&i->data, NULL);
327
328 if (Z_ISUNDEF(iter->current_val)) {
329 php_pqres_row_to_zval(obj->intern->res, iter->index, iter->fetch_type, &iter->current_val);
330 }
331 return &iter->current_val;
332 }
333
334 static void php_pqres_iterator_key(zend_object_iterator *i, zval *key)
335 {
336 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
337
338 ZVAL_LONG(key, iter->index);
339 }
340
341 static void php_pqres_iterator_invalidate(zend_object_iterator *i)
342 {
343 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
344
345 if (!Z_ISUNDEF(iter->current_val)) {
346 zval_ptr_dtor(&iter->current_val);
347 ZVAL_UNDEF(&iter->current_val);
348 }
349 }
350
351 static void php_pqres_iterator_next(zend_object_iterator *i)
352 {
353 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
354
355 php_pqres_iterator_invalidate(i);
356 ++iter->index;
357 }
358
359 static void php_pqres_iterator_rewind(zend_object_iterator *i)
360 {
361 php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
362
363 php_pqres_iterator_invalidate(i);
364 iter->index = 0;
365 }
366
367 static zend_object_iterator_funcs php_pqres_iterator_funcs = {
368 php_pqres_iterator_dtor,
369 /* check for end of iteration (FAILURE or SUCCESS if data is valid) */
370 php_pqres_iterator_valid,
371 /* fetch the item data for the current element */
372 php_pqres_iterator_current,
373 /* fetch the key for the current element (return HASH_KEY_IS_STRING or HASH_KEY_IS_LONG) (optional, may be NULL) */
374 php_pqres_iterator_key,
375 /* step forwards to next element */
376 php_pqres_iterator_next,
377 /* rewind to start of data (optional, may be NULL) */
378 php_pqres_iterator_rewind,
379 /* invalidate current value/key (optional, may be NULL) */
380 php_pqres_iterator_invalidate
381 };
382
383 static ZEND_RESULT_CODE php_pqres_count_elements(zval *object, long *count)
384 {
385 php_pqres_object_t *obj = PHP_PQ_OBJ(object, NULL);
386
387 if (!obj->intern) {
388 return FAILURE;
389 } else {
390 *count = (long) PQntuples(obj->intern->res);
391 return SUCCESS;
392 }
393 }
394
395 ZEND_RESULT_CODE php_pqres_success(PGresult *res)
396 {
397 zval zexc;
398
399 switch (PQresultStatus(res)) {
400 case PGRES_BAD_RESPONSE:
401 case PGRES_NONFATAL_ERROR:
402 case PGRES_FATAL_ERROR:
403 ZVAL_OBJ(&zexc, throw_exce(EX_SQL, "%s", PHP_PQresultErrorMessage(res)));
404 zend_update_property_string(Z_OBJCE(zexc), &zexc, ZEND_STRL("sqlstate"), PQresultErrorField(res, PG_DIAG_SQLSTATE));
405 return FAILURE;
406 default:
407 return SUCCESS;
408 }
409 }
410
411 php_pqres_object_t *php_pqres_init_instance_data(PGresult *res, php_pqconn_object_t *conn_obj)
412 {
413 php_pqres_object_t *obj;
414 php_pqres_t *r = ecalloc(1, sizeof(*r));
415
416 r->res = res;
417 zend_hash_init(&r->bound, 0, 0, ZVAL_PTR_DTOR, 0);
418 zend_hash_init(&r->converters, zend_hash_num_elements(&conn_obj->intern->converters), 0, ZVAL_PTR_DTOR, 0);
419 zend_hash_copy(&r->converters, &conn_obj->intern->converters, (copy_ctor_func_t) zval_add_ref);
420
421 r->auto_convert = conn_obj->intern->default_auto_convert;
422 r->default_fetch_type = conn_obj->intern->default_fetch_type;
423
424 obj = php_pqres_create_object_ex(php_pqres_class_entry, r);
425 PQresultSetInstanceData(res, php_pqconn_event, obj);
426
427 return obj;
428 }
429
430 php_pqres_fetch_t php_pqres_fetch_type(php_pqres_t *res)
431 {
432 return res->iter ? res->iter->fetch_type : res->default_fetch_type;
433 }
434
435 static void php_pqres_object_free(zend_object *o)
436 {
437 php_pqres_object_t *obj = PHP_PQ_OBJ(NULL, o);
438
439 if (obj->intern) {
440 if (obj->intern->res) {
441 PQresultSetInstanceData(obj->intern->res, php_pqconn_event, NULL);
442 PQclear(obj->intern->res);
443 obj->intern->res = NULL;
444 }
445
446 php_pqres_internal_iterator_dtor(obj);
447
448 zend_hash_destroy(&obj->intern->bound);
449 zend_hash_destroy(&obj->intern->converters);
450
451 efree(obj->intern);
452 obj->intern = NULL;
453 }
454 php_pq_object_dtor(o);
455 }
456
457 php_pqres_object_t *php_pqres_create_object_ex(zend_class_entry *ce, php_pqres_t *intern)
458 {
459 return php_pq_object_create(ce, intern, sizeof(php_pqres_object_t),
460 &php_pqres_object_handlers, &php_pqres_object_prophandlers);
461 }
462
463 static zend_object *php_pqres_create_object(zend_class_entry *class_type)
464 {
465 return &php_pqres_create_object_ex(class_type, NULL)->zo;
466 }
467
468 static void php_pqres_object_read_status(zval *object, void *o, zval *return_value)
469 {
470 php_pqres_object_t *obj = o;
471
472 RETVAL_LONG(PQresultStatus(obj->intern->res));
473 }
474
475 static void php_pqres_object_read_status_message(zval *object, void *o, zval *return_value)
476 {
477 php_pqres_object_t *obj = o;
478
479 RETVAL_STRING(PQresStatus(PQresultStatus(obj->intern->res))+sizeof("PGRES"));
480 }
481
482 static void php_pqres_object_read_error_message(zval *object, void *o, zval *return_value)
483 {
484 php_pqres_object_t *obj = o;
485 char *error = PHP_PQresultErrorMessage(obj->intern->res);
486
487 if (error) {
488 RETVAL_STRING(error);
489 } else {
490 RETVAL_NULL();
491 }
492 }
493
494 #ifndef PG_DIAG_SEVERITY
495 # define PG_DIAG_SEVERITY 'S'
496 #endif
497 #ifndef PG_DIAG_SQLSTATE
498 # define PG_DIAG_SQLSTATE 'C'
499 #endif
500 #ifndef PG_DIAG_MESSAGE_PRIMARY
501 # define PG_DIAG_MESSAGE_PRIMARY 'M'
502 #endif
503 #ifndef PG_DIAG_MESSAGE_DETAIL
504 # define PG_DIAG_MESSAGE_DETAIL 'D'
505 #endif
506 #ifndef PG_DIAG_MESSAGE_HINT
507 # define PG_DIAG_MESSAGE_HINT 'H'
508 #endif
509 #ifndef PG_DIAG_STATEMENT_POSITION
510 # define PG_DIAG_STATEMENT_POSITION 'P'
511 #endif
512 #ifndef PG_DIAG_INTERNAL_POSITION
513 # define PG_DIAG_INTERNAL_POSITION 'p'
514 #endif
515 #ifndef PG_DIAG_INTERNAL_QUERY
516 # define PG_DIAG_INTERNAL_QUERY 'q'
517 #endif
518 #ifndef PG_DIAG_CONTEXT
519 # define PG_DIAG_CONTEXT 'W'
520 #endif
521 #ifndef PG_DIAG_SCHEMA_NAME
522 # define PG_DIAG_SCHEMA_NAME 's'
523 #endif
524 #ifndef PG_DIAG_TABLE_NAME
525 # define PG_DIAG_TABLE_NAME 't'
526 #endif
527 #ifndef PG_DIAG_COLUMN_NAME
528 # define PG_DIAG_COLUMN_NAME 'c'
529 #endif
530 #ifndef PG_DIAG_DATATYPE_NAME
531 # define PG_DIAG_DATATYPE_NAME 'd'
532 #endif
533 #ifndef PG_DIAG_CONSTRAINT_NAME
534 # define PG_DIAG_CONSTRAINT_NAME 'n'
535 #endif
536 #ifndef PG_DIAG_SOURCE_FILE
537 # define PG_DIAG_SOURCE_FILE 'F'
538 #endif
539 #ifndef PG_DIAG_SOURCE_LINE
540 # define PG_DIAG_SOURCE_LINE 'L'
541 #endif
542 #ifndef PG_DIAG_SOURCE_FUNCTION
543 # define PG_DIAG_SOURCE_FUNCTION 'R'
544 #endif
545
546 static void php_pqres_object_read_diag(zval *object, void *o, zval *return_value)
547 {
548 php_pqres_object_t *obj = o;
549 int i;
550 struct {
551 char code;
552 const char *const name;
553 } diag[] = {
554 {PG_DIAG_SEVERITY, "severity"},
555 {PG_DIAG_SQLSTATE, "sqlstate"},
556 {PG_DIAG_MESSAGE_PRIMARY, "message_primary"},
557 {PG_DIAG_MESSAGE_DETAIL, "message_detail"},
558 {PG_DIAG_MESSAGE_HINT, "message_hint"},
559 {PG_DIAG_STATEMENT_POSITION,"statement_position"},
560 {PG_DIAG_INTERNAL_POSITION, "internal_position"},
561 {PG_DIAG_INTERNAL_QUERY, "internal_query"},
562 {PG_DIAG_CONTEXT, "context"},
563 {PG_DIAG_SCHEMA_NAME, "schema_name"},
564 {PG_DIAG_TABLE_NAME, "table_name"},
565 {PG_DIAG_COLUMN_NAME, "column_name"},
566 {PG_DIAG_DATATYPE_NAME, "datatype_name"},
567 {PG_DIAG_CONSTRAINT_NAME, "constraint_name"},
568 {PG_DIAG_SOURCE_FILE, "source_file"},
569 {PG_DIAG_SOURCE_LINE, "source_line"},
570 {PG_DIAG_SOURCE_FUNCTION, "source_function"},
571 };
572
573 array_init_size(return_value, 32);
574 for (i = 0; i < sizeof(diag)/sizeof(diag[0]); ++i) {
575 char *value = PQresultErrorField(obj->intern->res, diag[i].code);
576
577 if (value) {
578 add_assoc_string(return_value, diag[i].name, value);
579 } else {
580 add_assoc_null(return_value, diag[i].name);
581 }
582 }
583 }
584
585 static void php_pqres_object_read_num_rows(zval *object, void *o, zval *return_value)
586 {
587 php_pqres_object_t *obj = o;
588
589 RETVAL_LONG(PQntuples(obj->intern->res));
590 }
591
592 static void php_pqres_object_read_num_cols(zval *object, void *o, zval *return_value)
593 {
594 php_pqres_object_t *obj = o;
595
596 RETVAL_LONG(PQnfields(obj->intern->res));
597 }
598
599 static void php_pqres_object_read_affected_rows(zval *object, void *o, zval *return_value)
600 {
601 php_pqres_object_t *obj = o;
602
603 RETVAL_LONG(atoi(PQcmdTuples(obj->intern->res)));
604 }
605
606 static void php_pqres_object_read_fetch_type(zval *object, void *o, zval *return_value)
607 {
608 php_pqres_object_t *obj = o;
609
610 RETVAL_LONG(php_pqres_fetch_type(obj->intern));
611 }
612
613 static void php_pqres_object_write_fetch_type(zval *object, void *o, zval *value)
614 {
615 php_pqres_object_t *obj = o;
616
617 if (!obj->intern->iter) {
618 php_pqres_internal_iterator_init(object);
619 }
620 obj->intern->iter->fetch_type = zval_get_long(value);
621 }
622
623 static void php_pqres_object_read_auto_conv(zval *object, void *o, zval *return_value)
624 {
625 php_pqres_object_t *obj = o;
626
627 RETVAL_LONG(obj->intern->auto_convert);
628 }
629
630 static void php_pqres_object_write_auto_conv(zval *object, void *o, zval *value)
631 {
632 php_pqres_object_t *obj = o;
633
634 obj->intern->auto_convert = zval_get_long(value);
635 }
636
637 static ZEND_RESULT_CODE php_pqres_iteration(zval *zobj, php_pqres_object_t *obj, php_pqres_fetch_t fetch_type, zval *row)
638 {
639 ZEND_RESULT_CODE rv;
640 php_pqres_fetch_t orig_fetch;
641
642 if (!obj) {
643 obj = PHP_PQ_OBJ(zobj, NULL);
644 }
645
646 if (obj->intern->iter) {
647 obj->intern->iter->zi.funcs->move_forward((zend_object_iterator *) obj->intern->iter);
648 } else {
649 php_pqres_internal_iterator_init(zobj);
650 }
651 orig_fetch = obj->intern->iter->fetch_type;
652 obj->intern->iter->fetch_type = fetch_type;
653 if (SUCCESS == (rv = obj->intern->iter->zi.funcs->valid((zend_object_iterator *) obj->intern->iter))) {
654 zval *tmp = obj->intern->iter->zi.funcs->get_current_data((zend_object_iterator *) obj->intern->iter);
655 ZVAL_COPY_VALUE(row, tmp);
656 }
657 obj->intern->iter->fetch_type = orig_fetch;
658
659 return rv;
660 }
661
662 typedef struct php_pqres_col {
663 char *name;
664 int num;
665 } php_pqres_col_t;
666
667 static ZEND_RESULT_CODE column_nn(php_pqres_object_t *obj, zval *zcol, php_pqres_col_t *col)
668 {
669 zend_long index = -1;
670 char *name = NULL;
671
672 if (!zcol) {
673 index = 0;
674 } else {
675 switch (Z_TYPE_P(zcol)) {
676 case IS_NULL:
677 index = 0;
678 break;
679
680 case IS_LONG:
681 index = Z_LVAL_P(zcol);
682 break;
683
684 default:
685 convert_to_string(zcol);
686 /* no break */
687
688 case IS_STRING:
689 if (!is_numeric_string(Z_STRVAL_P(zcol), Z_STRLEN_P(zcol), &index, NULL, 0)) {
690 name = Z_STRVAL_P(zcol);
691 }
692 break;
693 }
694 }
695
696 if (name) {
697 col->name = name;
698 col->num = PQfnumber(obj->intern->res, name);
699 } else {
700 col->name = PQfname(obj->intern->res, index);
701 col->num = index;
702 }
703
704 if (!col->name) {
705 php_error_docref(NULL, E_WARNING, "Failed to find column at index %ld", index);
706 return FAILURE;
707 }
708 if (col->num == -1) {
709 php_error_docref(NULL, E_WARNING, "Failed to find column with name '%s'", name);
710 return FAILURE;
711 }
712 return SUCCESS;
713 }
714
715 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_bind, 0, 0, 2)
716 ZEND_ARG_INFO(0, col)
717 ZEND_ARG_INFO(1, ref)
718 ZEND_END_ARG_INFO();
719 static PHP_METHOD(pqres, bind) {
720 zval *zcol, *zref;
721 zend_error_handling zeh;
722 ZEND_RESULT_CODE rv;
723
724 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
725 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "z/z", &zcol, &zref);
726 zend_restore_error_handling(&zeh);
727
728 if (SUCCESS == rv) {
729 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
730
731 if (!obj->intern) {
732 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
733 } else {
734 php_pqres_col_t col;
735
736 if (SUCCESS != column_nn(obj, zcol, &col)) {
737 RETVAL_FALSE;
738 } else {
739 Z_TRY_ADDREF_P(zref);
740
741 if (!zend_hash_index_update(&obj->intern->bound, col.num, zref)) {
742 php_error_docref(NULL, E_WARNING, "Failed to bind column %s@%d", col.name, col.num);
743 RETVAL_FALSE;
744 } else {
745 zend_hash_sort(&obj->intern->bound, php_pq_compare_index, 0);
746 RETVAL_TRUE;
747 }
748 }
749 }
750 }
751 }
752
753 static int apply_bound(zval *zbound, int argc, va_list argv, zend_hash_key *key)
754 {
755 zval *zvalue;
756 zval *zrow = va_arg(argv, zval *);
757 ZEND_RESULT_CODE *rv = va_arg(argv, ZEND_RESULT_CODE *);
758
759 if (!(zvalue = zend_hash_index_find(Z_ARRVAL_P(zrow), key->h))) {
760 php_error_docref(NULL, E_WARNING, "Failed to find column ad index %lu", key->h);
761 *rv = FAILURE;
762 return ZEND_HASH_APPLY_STOP;
763 } else {
764 ZVAL_DEREF(zbound);
765 zval_dtor(zbound);
766 ZVAL_COPY(zbound, zvalue);
767 *rv = SUCCESS;
768 return ZEND_HASH_APPLY_KEEP;
769 }
770 }
771
772 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_bound, 0, 0, 0)
773 ZEND_END_ARG_INFO();
774 static PHP_METHOD(pqres, fetchBound) {
775 zend_error_handling zeh;
776 ZEND_RESULT_CODE rv;
777
778 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
779 rv = zend_parse_parameters_none();
780 zend_restore_error_handling(&zeh);
781
782 if (SUCCESS == rv) {
783 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
784
785 if (!obj->intern) {
786 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
787 } else {
788 zval row;
789
790 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
791 if (SUCCESS == php_pqres_iteration(getThis(), obj, PHP_PQRES_FETCH_ARRAY, &row)) {
792 zend_hash_apply_with_arguments(&obj->intern->bound, apply_bound, 2, &row, &rv);
793
794 if (SUCCESS == rv) {
795 RETVAL_ZVAL(&row, 1, 0);
796 }
797 }
798 zend_restore_error_handling(&zeh);
799 }
800 }
801 }
802
803 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_row, 0, 0, 0)
804 ZEND_ARG_INFO(0, fetch_type)
805 ZEND_END_ARG_INFO();
806 static PHP_METHOD(pqres, fetchRow) {
807 zend_error_handling zeh;
808 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
809 zend_long fetch_type = -1;
810 ZEND_RESULT_CODE rv;
811
812 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
813 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &fetch_type);
814 zend_restore_error_handling(&zeh);
815
816 if (SUCCESS == rv) {
817 if (!obj->intern) {
818 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
819 } else {
820 zval row;
821
822 if (fetch_type == -1) {
823 fetch_type = php_pqres_fetch_type(obj->intern);
824 }
825
826 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
827 if (SUCCESS == php_pqres_iteration(getThis(), obj, fetch_type, &row)) {
828 RETVAL_ZVAL(&row, 1, 0);
829 }
830 zend_restore_error_handling(&zeh);
831 }
832 }
833 }
834
835 static zval *column_at(zval *row, int col)
836 {
837 zval *data = NULL;
838 HashTable *ht = HASH_OF(row);
839 int count = zend_hash_num_elements(ht);
840
841 if (col >= count) {
842 php_error_docref(NULL, E_WARNING, "Column index %d exceeds column count %d", col, count);
843 } else {
844 zend_hash_internal_pointer_reset(ht);
845 while (col-- > 0) {
846 zend_hash_move_forward(ht);
847 }
848 data = zend_hash_get_current_data(ht);
849 }
850 return data;
851 }
852
853 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_col, 0, 0, 1)
854 ZEND_ARG_INFO(1, ref)
855 ZEND_ARG_INFO(0, col)
856 ZEND_END_ARG_INFO();
857 static PHP_METHOD(pqres, fetchCol) {
858 zend_error_handling zeh;
859 zval *zcol = NULL, *zref;
860 ZEND_RESULT_CODE rv;
861
862 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
863 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "z|z/!", &zref, &zcol);
864 zend_restore_error_handling(&zeh);
865
866 if (SUCCESS == rv) {
867 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
868
869 if (!obj->intern) {
870 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
871 } else {
872 zval row;
873
874 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
875 if (SUCCESS == php_pqres_iteration(getThis(), obj, php_pqres_fetch_type(obj->intern), &row)) {
876 php_pqres_col_t col;
877
878 if (SUCCESS != column_nn(obj, zcol, &col)) {
879 RETVAL_FALSE;
880 } else {
881 zval *zres = column_at(&row, col.num);
882
883 if (!zres) {
884 RETVAL_FALSE;
885 } else {
886 ZVAL_DEREF(zref);
887 zval_dtor(zref);
888 ZVAL_ZVAL(zref, zres, 1, 0);
889 RETVAL_TRUE;
890 }
891 }
892 }
893 zend_restore_error_handling(&zeh);
894 }
895 }
896 }
897
898 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_all_cols, 0, 0, 0)
899 ZEND_ARG_INFO(0, col)
900 ZEND_END_ARG_INFO();
901 static PHP_METHOD(pqres, fetchAllCols) {
902 zend_error_handling zeh;
903 zval *zcol = NULL;
904 ZEND_RESULT_CODE rv;
905
906 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
907 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|z!", &zcol);
908 zend_restore_error_handling(&zeh);
909
910 if (SUCCESS == rv) {
911 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
912
913 if (!obj->intern) {
914 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
915 } else {
916 php_pqres_col_t col;
917
918 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
919 if (SUCCESS == column_nn(obj, zcol, &col)) {
920 int r, rows = PQntuples(obj->intern->res);
921 zval tmp;
922
923 array_init(return_value);
924 for (r = 0; r < rows; ++r) {
925 add_next_index_zval(return_value, php_pqres_get_col(obj->intern, r, col.num, &tmp));
926 }
927 }
928 zend_restore_error_handling(&zeh);
929 }
930 }
931 }
932
933 struct apply_to_col_arg {
934 php_pqres_object_t *obj;
935 php_pqres_col_t *cols;
936 ZEND_RESULT_CODE status;
937 };
938
939 static int apply_to_col(zval *c, void *a)
940 {
941 struct apply_to_col_arg *arg = a;
942
943 if (SUCCESS != column_nn(arg->obj, c, arg->cols)) {
944 arg->status = FAILURE;
945 return ZEND_HASH_APPLY_STOP;
946 } else {
947 arg->status = SUCCESS;
948 ++arg->cols;
949 return ZEND_HASH_APPLY_KEEP;
950 }
951 }
952
953 static php_pqres_col_t *php_pqres_convert_to_cols(php_pqres_object_t *obj, HashTable *ht)
954 {
955 struct apply_to_col_arg arg = {NULL};
956 php_pqres_col_t *tmp;
957
958 arg.obj = obj;
959 arg.cols = ecalloc(zend_hash_num_elements(ht), sizeof(*tmp));
960 tmp = arg.cols;
961 zend_hash_apply_with_argument(ht, apply_to_col, &arg);
962
963 if (SUCCESS == arg.status) {
964 return tmp;
965 } else {
966 efree(tmp);
967 return NULL;
968 }
969 }
970
971 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_map, 0, 0, 0)
972 ZEND_ARG_INFO(0, keys)
973 ZEND_ARG_INFO(0, vals)
974 ZEND_ARG_INFO(0, fetch_type)
975 ZEND_END_ARG_INFO();
976 static PHP_METHOD(pqres, map) {
977 zend_error_handling zeh;
978 zval *zkeys = 0, *zvals = 0;
979 zend_long fetch_type = -1;
980 ZEND_RESULT_CODE rv;
981
982 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
983 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|z/!z/!l", &zkeys, &zvals, &fetch_type);
984 zend_restore_error_handling(&zeh);
985
986 if (SUCCESS == rv) {
987 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
988
989 if (!obj->intern) {
990 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
991 } else {
992 int ks = 0, vs = 0;
993 php_pqres_col_t def = {PQfname(obj->intern->res, 0), 0}, *keys = NULL, *vals = NULL;
994
995 if (zkeys) {
996 convert_to_array(zkeys);
997
998 if ((ks = zend_hash_num_elements(Z_ARRVAL_P(zkeys)))) {
999 keys = php_pqres_convert_to_cols(obj, Z_ARRVAL_P(zkeys));
1000 } else {
1001 ks = 1;
1002 keys = &def;
1003 }
1004 } else {
1005 ks = 1;
1006 keys = &def;
1007 }
1008 if (zvals) {
1009 convert_to_array(zvals);
1010
1011 if ((vs = zend_hash_num_elements(Z_ARRVAL_P(zvals)))) {
1012 vals = php_pqres_convert_to_cols(obj, Z_ARRVAL_P(zvals));
1013 }
1014 }
1015
1016 if (fetch_type == -1) {
1017 fetch_type = php_pqres_fetch_type(obj->intern);
1018 }
1019
1020 if (keys) {
1021 int rows, r;
1022 zval *cur;
1023
1024 switch (fetch_type) {
1025 case PHP_PQRES_FETCH_ARRAY:
1026 case PHP_PQRES_FETCH_ASSOC:
1027 array_init(return_value);
1028 break;
1029 case PHP_PQRES_FETCH_OBJECT:
1030 object_init(return_value);
1031 break;
1032 }
1033 for (r = 0, rows = PQntuples(obj->intern->res); r < rows; ++r) {
1034 int k, v;
1035 zval *ptr;
1036
1037 cur = return_value;
1038 for (k = 0; k < ks; ++k) {
1039 char *key = PQgetvalue(obj->intern->res, r, keys[k].num);
1040 int len = PQgetlength(obj->intern->res, r, keys[k].num);
1041
1042 if (!(ptr = zend_symtable_str_find(HASH_OF(cur), key, len))) {
1043 zval tmp;
1044
1045 switch (fetch_type) {
1046 case PHP_PQRES_FETCH_ARRAY:
1047 case PHP_PQRES_FETCH_ASSOC:
1048 array_init(&tmp);
1049 break;
1050 case PHP_PQRES_FETCH_OBJECT:
1051 object_init(&tmp);
1052 break;
1053 }
1054 if (!(ptr = zend_symtable_str_update(HASH_OF(cur), key, len, &tmp))) {
1055 throw_exce(EX_RUNTIME, "Failed to create map");
1056 goto err;
1057 }
1058 cur = ptr;
1059 }
1060 cur = ptr;
1061 }
1062 if (vals && vs) {
1063 for (v = 0; v < vs; ++v) {
1064 char *val = PQgetvalue(obj->intern->res, r, vals[v].num);
1065 int len = PQgetlength(obj->intern->res, r, vals[v].num);
1066
1067 switch (fetch_type) {
1068 case PHP_PQRES_FETCH_ARRAY:
1069 add_index_stringl(cur, vals[v].num, val, len);
1070 break;
1071 case PHP_PQRES_FETCH_ASSOC:
1072 add_assoc_stringl(cur, vals[v].name, val, len);
1073 break;
1074 case PHP_PQRES_FETCH_OBJECT:
1075 add_property_stringl(cur, vals[v].name, val, len);
1076 break;
1077 }
1078 }
1079 } else {
1080 php_pqres_row_to_zval(obj->intern->res, r, fetch_type, cur);
1081 }
1082 }
1083 }
1084
1085 err:
1086 if (keys && keys != &def) {
1087 efree(keys);
1088 }
1089 if (vals) {
1090 efree(vals);
1091 }
1092 }
1093 }
1094 }
1095
1096 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_all, 0, 0, 0)
1097 ZEND_ARG_INFO(0, fetch_type)
1098 ZEND_END_ARG_INFO();
1099 static PHP_METHOD(pqres, fetchAll) {
1100 zend_error_handling zeh;
1101 zend_long fetch_type = -1;
1102 ZEND_RESULT_CODE rv;
1103
1104 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1105 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &fetch_type);
1106 zend_restore_error_handling(&zeh);
1107
1108 if (SUCCESS == rv) {
1109 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
1110
1111 if (!obj->intern) {
1112 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1113 } else {
1114 int r, rows = PQntuples(obj->intern->res);
1115 zval tmp;
1116
1117 if (fetch_type == -1) {
1118 fetch_type = php_pqres_fetch_type(obj->intern);
1119 }
1120
1121 array_init(return_value);
1122 for (r = 0; r < rows; ++r) {
1123 ZVAL_NULL(&tmp);
1124 add_next_index_zval(return_value, php_pqres_row_to_zval(obj->intern->res, r, fetch_type, &tmp));
1125 }
1126 }
1127 }
1128 }
1129
1130 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_count, 0, 0, 0)
1131 ZEND_END_ARG_INFO();
1132 static PHP_METHOD(pqres, count) {
1133 zend_error_handling zeh;
1134 ZEND_RESULT_CODE rv;
1135
1136 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1137 rv = zend_parse_parameters_none();
1138 zend_restore_error_handling(&zeh);
1139
1140 if (SUCCESS == rv) {
1141 long count;
1142
1143 if (SUCCESS != php_pqres_count_elements(getThis(), &count)) {
1144 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1145 } else {
1146 RETVAL_LONG(count);
1147 }
1148 }
1149 }
1150
1151 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_desc, 0, 0, 0)
1152 ZEND_END_ARG_INFO();
1153 static PHP_METHOD(pqres, desc) {
1154 zend_error_handling zeh;
1155 ZEND_RESULT_CODE rv;
1156
1157 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1158 rv = zend_parse_parameters_none();
1159 zend_restore_error_handling(&zeh);
1160
1161 if (SUCCESS == rv) {
1162 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
1163
1164 if (!obj->intern) {
1165 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1166 } else {
1167 int p, params;
1168
1169 array_init(return_value);
1170 for (p = 0, params = PQnparams(obj->intern->res); p < params; ++p) {
1171 add_next_index_long(return_value, PQparamtype(obj->intern->res, p));
1172 }
1173 }
1174 }
1175 }
1176
1177 static zend_function_entry php_pqres_methods[] = {
1178 PHP_ME(pqres, bind, ai_pqres_bind, ZEND_ACC_PUBLIC)
1179 PHP_ME(pqres, fetchBound, ai_pqres_fetch_bound, ZEND_ACC_PUBLIC)
1180 PHP_ME(pqres, fetchRow, ai_pqres_fetch_row, ZEND_ACC_PUBLIC)
1181 PHP_ME(pqres, fetchCol, ai_pqres_fetch_col, ZEND_ACC_PUBLIC)
1182 PHP_ME(pqres, fetchAll, ai_pqres_fetch_all, ZEND_ACC_PUBLIC)
1183 PHP_ME(pqres, fetchAllCols, ai_pqres_fetch_all_cols, ZEND_ACC_PUBLIC)
1184 PHP_ME(pqres, count, ai_pqres_count, ZEND_ACC_PUBLIC)
1185 PHP_ME(pqres, map, ai_pqres_map, ZEND_ACC_PUBLIC)
1186 PHP_ME(pqres, desc, ai_pqres_desc, ZEND_ACC_PUBLIC)
1187 {0}
1188 };
1189
1190 PHP_MSHUTDOWN_FUNCTION(pqres)
1191 {
1192 zend_hash_destroy(&php_pqres_object_prophandlers);
1193 return SUCCESS;
1194 }
1195
1196 PHP_MINIT_FUNCTION(pqres)
1197 {
1198 zend_class_entry ce = {0};
1199 php_pq_object_prophandler_t ph = {0};
1200
1201 INIT_NS_CLASS_ENTRY(ce, "pq", "Result", php_pqres_methods);
1202 php_pqres_class_entry = zend_register_internal_class_ex(&ce, NULL);
1203 php_pqres_class_entry->create_object = php_pqres_create_object;
1204 php_pqres_class_entry->get_iterator = php_pqres_iterator_init;
1205 zend_class_implements(php_pqres_class_entry, 2, zend_ce_traversable, spl_ce_Countable);
1206
1207 memcpy(&php_pqres_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1208 php_pqres_object_handlers.offset = XtOffsetOf(php_pqres_object_t, zo);
1209 php_pqres_object_handlers.free_obj = php_pqres_object_free;
1210 php_pqres_object_handlers.read_property = php_pq_object_read_prop;
1211 php_pqres_object_handlers.write_property = php_pq_object_write_prop;
1212 php_pqres_object_handlers.clone_obj = NULL;
1213 php_pqres_object_handlers.get_property_ptr_ptr = php_pq_object_get_prop_ptr_null;
1214 php_pqres_object_handlers.get_gc = php_pq_object_get_gc;
1215 php_pqres_object_handlers.get_debug_info = php_pq_object_debug_info;
1216 php_pqres_object_handlers.get_properties = php_pq_object_properties;
1217 php_pqres_object_handlers.count_elements = php_pqres_count_elements;
1218
1219 zend_hash_init(&php_pqres_object_prophandlers, 9, NULL, php_pq_object_prophandler_dtor, 1);
1220
1221 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("status"), ZEND_ACC_PUBLIC);
1222 ph.read = php_pqres_object_read_status;
1223 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "status", sizeof("status")-1, (void *) &ph, sizeof(ph));
1224
1225 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("statusMessage"), ZEND_ACC_PUBLIC);
1226 ph.read = php_pqres_object_read_status_message;
1227 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "statusMessage", sizeof("statusMessage")-1, (void *) &ph, sizeof(ph));
1228
1229 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("errorMessage"), ZEND_ACC_PUBLIC);
1230 ph.read = php_pqres_object_read_error_message;
1231 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "errorMessage", sizeof("errorMessage")-1, (void *) &ph, sizeof(ph));
1232
1233 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("diag"), ZEND_ACC_PUBLIC);
1234 ph.read = php_pqres_object_read_diag;
1235 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "diag", sizeof("diag")-1, (void *) &ph, sizeof(ph));
1236
1237 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("numRows"), 0, ZEND_ACC_PUBLIC);
1238 ph.read = php_pqres_object_read_num_rows;
1239 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "numRows", sizeof("numRows")-1, (void *) &ph, sizeof(ph));
1240
1241 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("numCols"), 0, ZEND_ACC_PUBLIC);
1242 ph.read = php_pqres_object_read_num_cols;
1243 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "numCols", sizeof("numCols")-1, (void *) &ph, sizeof(ph));
1244
1245 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("affectedRows"), 0, ZEND_ACC_PUBLIC);
1246 ph.read = php_pqres_object_read_affected_rows;
1247 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "affectedRows", sizeof("affectedRows")-1, (void *) &ph, sizeof(ph));
1248
1249 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("fetchType"), PHP_PQRES_FETCH_ARRAY, ZEND_ACC_PUBLIC);
1250 ph.read = php_pqres_object_read_fetch_type;
1251 ph.write = php_pqres_object_write_fetch_type;
1252 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "fetchType", sizeof("fetchType")-1, (void *) &ph, sizeof(ph));
1253 ph.write = NULL;
1254
1255 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("autoConvert"), PHP_PQRES_CONV_ALL, ZEND_ACC_PUBLIC);
1256 ph.read = php_pqres_object_read_auto_conv;
1257 ph.write = php_pqres_object_write_auto_conv;
1258 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "autoConvert", sizeof("autoConvert")-1, (void *) &ph, sizeof(ph));
1259 ph.write = NULL;
1260
1261 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("EMPTY_QUERY"), PGRES_EMPTY_QUERY);
1262 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COMMAND_OK"), PGRES_COMMAND_OK);
1263 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("TUPLES_OK"), PGRES_TUPLES_OK);
1264 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_OUT"), PGRES_COPY_OUT);
1265 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_IN"), PGRES_COPY_IN);
1266 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("BAD_RESPONSE"), PGRES_BAD_RESPONSE);
1267 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("NONFATAL_ERROR"), PGRES_NONFATAL_ERROR);
1268 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FATAL_ERROR"), PGRES_FATAL_ERROR);
1269 #ifdef HAVE_PGRES_COPY_BOTH
1270 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_BOTH"), PGRES_COPY_BOTH);
1271 #endif
1272 #ifdef HAVE_PGRES_SINGLE_TUPLE
1273 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("SINGLE_TUPLE"), PGRES_SINGLE_TUPLE);
1274 #endif
1275
1276 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FETCH_ARRAY"), PHP_PQRES_FETCH_ARRAY);
1277 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FETCH_ASSOC"), PHP_PQRES_FETCH_ASSOC);
1278 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FETCH_OBJECT"), PHP_PQRES_FETCH_OBJECT);
1279
1280 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_BOOL"), PHP_PQRES_CONV_BOOL);
1281 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_INT"), PHP_PQRES_CONV_INT);
1282 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_FLOAT"), PHP_PQRES_CONV_FLOAT);
1283 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_SCALAR"), PHP_PQRES_CONV_SCALAR);
1284 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_ARRAY"), PHP_PQRES_CONV_ARRAY);
1285 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_DATETIME"), PHP_PQRES_CONV_DATETIME);
1286 #if PHP_PQ_HAVE_PHP_JSON_H
1287 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_JSON"), PHP_PQRES_CONV_JSON);
1288 #endif
1289 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_ALL"), PHP_PQRES_CONV_ALL);
1290
1291 return SUCCESS;
1292 }
1293
1294 /*
1295 * Local variables:
1296 * tab-width: 4
1297 * c-basic-offset: 4
1298 * End:
1299 * vim600: noet sw=4 ts=4 fdm=marker
1300 * vim<600: noet sw=4 ts=4
1301 */
PostgreSQL client library (libpq) binding