projects / m6w6 / ext-pq / blob
? search:


154cd961a39a0eb4d5f5d0ebdc83f494686b4459
[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 = php_pq_read_property(object, "fetchType", &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 php_pq_call_method(zconv, "convertfromstring", 2, &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 #if PHP_VERSION_ID >= 80000
382 , NULL
383 #endif
384 };
385
386 #if PHP_VERSION_ID >= 80000
387 # define php_pqres_count_elements php_pqres_count_elements_80
388 #else
389 # define php_pqres_count_elements php_pqres_count_elements_70
390 #endif
391 static ZEND_RESULT_CODE php_pqres_count_elements_80(zend_object *object, long *count)
392 {
393 php_pqres_object_t *obj = PHP_PQ_OBJ(NULL, object);
394
395 if (!obj->intern) {
396 return FAILURE;
397 } else {
398 *count = (long) PQntuples(obj->intern->res);
399 return SUCCESS;
400 }
401 }
402 static ZEND_RESULT_CODE php_pqres_count_elements_70(zval *object, long *count)
403 {
404 return php_pqres_count_elements_80(Z_OBJ_P(object), count);
405 }
406
407 ZEND_RESULT_CODE php_pqres_success(PGresult *res)
408 {
409 zval zexc, zsqlstate;
410
411 switch (PQresultStatus(res)) {
412 case PGRES_BAD_RESPONSE:
413 case PGRES_NONFATAL_ERROR:
414 case PGRES_FATAL_ERROR:
415 ZVAL_OBJ(&zexc, throw_exce(EX_SQL, "%s", PHP_PQresultErrorMessage(res)));
416 ZVAL_STRING(&zsqlstate, PQresultErrorField(res, PG_DIAG_SQLSTATE));
417 php_pq_update_property(&zexc, "sqlstate", &zsqlstate);
418 zval_ptr_dtor(&zsqlstate);
419 return FAILURE;
420 default:
421 return SUCCESS;
422 }
423 }
424
425 php_pqres_object_t *php_pqres_init_instance_data(PGresult *res, php_pqconn_object_t *conn_obj)
426 {
427 php_pqres_object_t *obj;
428 php_pqres_t *r = ecalloc(1, sizeof(*r));
429
430 r->res = res;
431 zend_hash_init(&r->bound, 0, 0, ZVAL_PTR_DTOR, 0);
432 zend_hash_init(&r->converters, zend_hash_num_elements(&conn_obj->intern->converters), 0, ZVAL_PTR_DTOR, 0);
433 zend_hash_copy(&r->converters, &conn_obj->intern->converters, (copy_ctor_func_t) zval_add_ref);
434
435 r->auto_convert = conn_obj->intern->default_auto_convert;
436 r->default_fetch_type = conn_obj->intern->default_fetch_type;
437
438 obj = php_pqres_create_object_ex(php_pqres_class_entry, r);
439 PQresultSetInstanceData(res, php_pqconn_event, obj);
440
441 return obj;
442 }
443
444 php_pqres_fetch_t php_pqres_fetch_type(php_pqres_t *res)
445 {
446 return res->iter ? res->iter->fetch_type : res->default_fetch_type;
447 }
448
449 static void php_pqres_object_free(zend_object *o)
450 {
451 php_pqres_object_t *obj = PHP_PQ_OBJ(NULL, o);
452
453 if (obj->intern) {
454 if (obj->intern->res) {
455 PQresultSetInstanceData(obj->intern->res, php_pqconn_event, NULL);
456 PQclear(obj->intern->res);
457 obj->intern->res = NULL;
458 }
459
460 php_pqres_internal_iterator_dtor(obj);
461
462 zend_hash_destroy(&obj->intern->bound);
463 zend_hash_destroy(&obj->intern->converters);
464
465 efree(obj->intern);
466 obj->intern = NULL;
467 }
468 php_pq_object_dtor(o);
469 }
470
471 php_pqres_object_t *php_pqres_create_object_ex(zend_class_entry *ce, php_pqres_t *intern)
472 {
473 return php_pq_object_create(ce, intern, sizeof(php_pqres_object_t),
474 &php_pqres_object_handlers, &php_pqres_object_prophandlers);
475 }
476
477 static zend_object *php_pqres_create_object(zend_class_entry *class_type)
478 {
479 return &php_pqres_create_object_ex(class_type, NULL)->zo;
480 }
481
482 static void php_pqres_object_read_status(void *o, zval *return_value)
483 {
484 php_pqres_object_t *obj = o;
485
486 RETVAL_LONG(PQresultStatus(obj->intern->res));
487 }
488
489 static void php_pqres_object_read_status_message(void *o, zval *return_value)
490 {
491 php_pqres_object_t *obj = o;
492
493 RETVAL_STRING(PQresStatus(PQresultStatus(obj->intern->res))+sizeof("PGRES"));
494 }
495
496 static void php_pqres_object_read_error_message(void *o, zval *return_value)
497 {
498 php_pqres_object_t *obj = o;
499 char *error = PHP_PQresultErrorMessage(obj->intern->res);
500
501 if (error) {
502 RETVAL_STRING(error);
503 } else {
504 RETVAL_NULL();
505 }
506 }
507
508 #ifndef PG_DIAG_SEVERITY
509 # define PG_DIAG_SEVERITY 'S'
510 #endif
511 #ifndef PG_DIAG_SQLSTATE
512 # define PG_DIAG_SQLSTATE 'C'
513 #endif
514 #ifndef PG_DIAG_MESSAGE_PRIMARY
515 # define PG_DIAG_MESSAGE_PRIMARY 'M'
516 #endif
517 #ifndef PG_DIAG_MESSAGE_DETAIL
518 # define PG_DIAG_MESSAGE_DETAIL 'D'
519 #endif
520 #ifndef PG_DIAG_MESSAGE_HINT
521 # define PG_DIAG_MESSAGE_HINT 'H'
522 #endif
523 #ifndef PG_DIAG_STATEMENT_POSITION
524 # define PG_DIAG_STATEMENT_POSITION 'P'
525 #endif
526 #ifndef PG_DIAG_INTERNAL_POSITION
527 # define PG_DIAG_INTERNAL_POSITION 'p'
528 #endif
529 #ifndef PG_DIAG_INTERNAL_QUERY
530 # define PG_DIAG_INTERNAL_QUERY 'q'
531 #endif
532 #ifndef PG_DIAG_CONTEXT
533 # define PG_DIAG_CONTEXT 'W'
534 #endif
535 #ifndef PG_DIAG_SCHEMA_NAME
536 # define PG_DIAG_SCHEMA_NAME 's'
537 #endif
538 #ifndef PG_DIAG_TABLE_NAME
539 # define PG_DIAG_TABLE_NAME 't'
540 #endif
541 #ifndef PG_DIAG_COLUMN_NAME
542 # define PG_DIAG_COLUMN_NAME 'c'
543 #endif
544 #ifndef PG_DIAG_DATATYPE_NAME
545 # define PG_DIAG_DATATYPE_NAME 'd'
546 #endif
547 #ifndef PG_DIAG_CONSTRAINT_NAME
548 # define PG_DIAG_CONSTRAINT_NAME 'n'
549 #endif
550 #ifndef PG_DIAG_SOURCE_FILE
551 # define PG_DIAG_SOURCE_FILE 'F'
552 #endif
553 #ifndef PG_DIAG_SOURCE_LINE
554 # define PG_DIAG_SOURCE_LINE 'L'
555 #endif
556 #ifndef PG_DIAG_SOURCE_FUNCTION
557 # define PG_DIAG_SOURCE_FUNCTION 'R'
558 #endif
559
560 static void php_pqres_object_read_diag(void *o, zval *return_value)
561 {
562 php_pqres_object_t *obj = o;
563 int i;
564 struct {
565 char code;
566 const char *const name;
567 } diag[] = {
568 {PG_DIAG_SEVERITY, "severity"},
569 {PG_DIAG_SQLSTATE, "sqlstate"},
570 {PG_DIAG_MESSAGE_PRIMARY, "message_primary"},
571 {PG_DIAG_MESSAGE_DETAIL, "message_detail"},
572 {PG_DIAG_MESSAGE_HINT, "message_hint"},
573 {PG_DIAG_STATEMENT_POSITION,"statement_position"},
574 {PG_DIAG_INTERNAL_POSITION, "internal_position"},
575 {PG_DIAG_INTERNAL_QUERY, "internal_query"},
576 {PG_DIAG_CONTEXT, "context"},
577 {PG_DIAG_SCHEMA_NAME, "schema_name"},
578 {PG_DIAG_TABLE_NAME, "table_name"},
579 {PG_DIAG_COLUMN_NAME, "column_name"},
580 {PG_DIAG_DATATYPE_NAME, "datatype_name"},
581 {PG_DIAG_CONSTRAINT_NAME, "constraint_name"},
582 {PG_DIAG_SOURCE_FILE, "source_file"},
583 {PG_DIAG_SOURCE_LINE, "source_line"},
584 {PG_DIAG_SOURCE_FUNCTION, "source_function"},
585 };
586
587 array_init_size(return_value, 32);
588 for (i = 0; i < sizeof(diag)/sizeof(diag[0]); ++i) {
589 char *value = PQresultErrorField(obj->intern->res, diag[i].code);
590
591 if (value) {
592 add_assoc_string(return_value, diag[i].name, value);
593 } else {
594 add_assoc_null(return_value, diag[i].name);
595 }
596 }
597 }
598
599 static void php_pqres_object_read_num_rows(void *o, zval *return_value)
600 {
601 php_pqres_object_t *obj = o;
602
603 RETVAL_LONG(PQntuples(obj->intern->res));
604 }
605
606 static void php_pqres_object_read_num_cols(void *o, zval *return_value)
607 {
608 php_pqres_object_t *obj = o;
609
610 RETVAL_LONG(PQnfields(obj->intern->res));
611 }
612
613 static void php_pqres_object_read_affected_rows(void *o, zval *return_value)
614 {
615 php_pqres_object_t *obj = o;
616
617 RETVAL_LONG(atoi(PQcmdTuples(obj->intern->res)));
618 }
619
620 static void php_pqres_object_read_fetch_type(void *o, zval *return_value)
621 {
622 php_pqres_object_t *obj = o;
623
624 RETVAL_LONG(php_pqres_fetch_type(obj->intern));
625 }
626
627 static void php_pqres_object_write_fetch_type(void *o, zval *value)
628 {
629 php_pqres_object_t *obj = o;
630
631 if (!obj->intern->iter) {
632 zval object;
633
634 ZVAL_OBJ(&object, &obj->zo);
635 php_pqres_internal_iterator_init(&object);
636 }
637 obj->intern->iter->fetch_type = zval_get_long(value);
638 }
639
640 static void php_pqres_object_read_auto_conv(void *o, zval *return_value)
641 {
642 php_pqres_object_t *obj = o;
643
644 RETVAL_LONG(obj->intern->auto_convert);
645 }
646
647 static void php_pqres_object_write_auto_conv(void *o, zval *value)
648 {
649 php_pqres_object_t *obj = o;
650
651 obj->intern->auto_convert = zval_get_long(value);
652 }
653
654 static ZEND_RESULT_CODE php_pqres_iteration(zval *zobj, php_pqres_object_t *obj, php_pqres_fetch_t fetch_type, zval *row)
655 {
656 ZEND_RESULT_CODE rv;
657 php_pqres_fetch_t orig_fetch;
658
659 if (!obj) {
660 obj = PHP_PQ_OBJ(zobj, NULL);
661 }
662
663 if (obj->intern->iter) {
664 obj->intern->iter->zi.funcs->move_forward((zend_object_iterator *) obj->intern->iter);
665 } else {
666 php_pqres_internal_iterator_init(zobj);
667 }
668 orig_fetch = obj->intern->iter->fetch_type;
669 obj->intern->iter->fetch_type = fetch_type;
670 if (SUCCESS == (rv = obj->intern->iter->zi.funcs->valid((zend_object_iterator *) obj->intern->iter))) {
671 zval *tmp = obj->intern->iter->zi.funcs->get_current_data((zend_object_iterator *) obj->intern->iter);
672 ZVAL_COPY_VALUE(row, tmp);
673 }
674 obj->intern->iter->fetch_type = orig_fetch;
675
676 return rv;
677 }
678
679 typedef struct php_pqres_col {
680 char *name;
681 int num;
682 } php_pqres_col_t;
683
684 static ZEND_RESULT_CODE column_nn(php_pqres_object_t *obj, zval *zcol, php_pqres_col_t *col)
685 {
686 zend_long index = -1;
687 char *name = NULL;
688
689 if (!zcol) {
690 index = 0;
691 } else {
692 switch (Z_TYPE_P(zcol)) {
693 case IS_NULL:
694 index = 0;
695 break;
696
697 case IS_LONG:
698 index = Z_LVAL_P(zcol);
699 break;
700
701 default:
702 convert_to_string(zcol);
703 /* no break */
704
705 case IS_STRING:
706 if (!is_numeric_string(Z_STRVAL_P(zcol), Z_STRLEN_P(zcol), &index, NULL, 0)) {
707 name = Z_STRVAL_P(zcol);
708 }
709 break;
710 }
711 }
712
713 if (name) {
714 col->name = name;
715 col->num = PQfnumber(obj->intern->res, name);
716 } else {
717 col->name = PQfname(obj->intern->res, index);
718 col->num = index;
719 }
720
721 if (!col->name) {
722 php_error_docref(NULL, E_WARNING, "Failed to find column at index %ld", index);
723 return FAILURE;
724 }
725 if (col->num == -1) {
726 php_error_docref(NULL, E_WARNING, "Failed to find column with name '%s'", name);
727 return FAILURE;
728 }
729 return SUCCESS;
730 }
731
732 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_bind, 0, 0, 2)
733 ZEND_ARG_INFO(0, col)
734 ZEND_ARG_INFO(1, ref)
735 ZEND_END_ARG_INFO();
736 static PHP_METHOD(pqres, bind) {
737 zval *zcol, *zref;
738 zend_error_handling zeh;
739 ZEND_RESULT_CODE rv;
740
741 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
742 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "z/z", &zcol, &zref);
743 zend_restore_error_handling(&zeh);
744
745 if (SUCCESS == rv) {
746 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
747
748 if (!obj->intern) {
749 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
750 } else {
751 php_pqres_col_t col;
752
753 if (SUCCESS != column_nn(obj, zcol, &col)) {
754 RETVAL_FALSE;
755 } else {
756 Z_TRY_ADDREF_P(zref);
757
758 if (!zend_hash_index_update(&obj->intern->bound, col.num, zref)) {
759 php_error_docref(NULL, E_WARNING, "Failed to bind column %s@%d", col.name, col.num);
760 RETVAL_FALSE;
761 } else {
762 zend_hash_sort(&obj->intern->bound, php_pq_compare_index, 0);
763 RETVAL_TRUE;
764 }
765 }
766 }
767 }
768 }
769
770 static int apply_bound(zval *zbound, int argc, va_list argv, zend_hash_key *key)
771 {
772 zval *zvalue;
773 zval *zrow = va_arg(argv, zval *);
774 ZEND_RESULT_CODE *rv = va_arg(argv, ZEND_RESULT_CODE *);
775
776 if (!(zvalue = zend_hash_index_find(Z_ARRVAL_P(zrow), key->h))) {
777 php_error_docref(NULL, E_WARNING, "Failed to find column ad index %lu", key->h);
778 *rv = FAILURE;
779 return ZEND_HASH_APPLY_STOP;
780 } else {
781 ZVAL_DEREF(zbound);
782 zval_dtor(zbound);
783 ZVAL_COPY(zbound, zvalue);
784 *rv = SUCCESS;
785 return ZEND_HASH_APPLY_KEEP;
786 }
787 }
788
789 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_bound, 0, 0, 0)
790 ZEND_END_ARG_INFO();
791 static PHP_METHOD(pqres, fetchBound) {
792 zend_error_handling zeh;
793 ZEND_RESULT_CODE rv;
794
795 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
796 rv = zend_parse_parameters_none();
797 zend_restore_error_handling(&zeh);
798
799 if (SUCCESS == rv) {
800 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
801
802 if (!obj->intern) {
803 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
804 } else {
805 zval row;
806
807 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
808 if (SUCCESS == php_pqres_iteration(getThis(), obj, PHP_PQRES_FETCH_ARRAY, &row)) {
809 zend_hash_apply_with_arguments(&obj->intern->bound, apply_bound, 2, &row, &rv);
810
811 if (SUCCESS == rv) {
812 RETVAL_ZVAL(&row, 1, 0);
813 }
814 }
815 zend_restore_error_handling(&zeh);
816 }
817 }
818 }
819
820 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_row, 0, 0, 0)
821 ZEND_ARG_INFO(0, fetch_type)
822 ZEND_END_ARG_INFO();
823 static PHP_METHOD(pqres, fetchRow) {
824 zend_error_handling zeh;
825 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
826 zend_long fetch_type = -1;
827 ZEND_RESULT_CODE rv;
828
829 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
830 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &fetch_type);
831 zend_restore_error_handling(&zeh);
832
833 if (SUCCESS == rv) {
834 if (!obj->intern) {
835 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
836 } else {
837 zval row;
838
839 if (fetch_type == -1) {
840 fetch_type = php_pqres_fetch_type(obj->intern);
841 }
842
843 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
844 if (SUCCESS == php_pqres_iteration(getThis(), obj, fetch_type, &row)) {
845 RETVAL_ZVAL(&row, 1, 0);
846 }
847 zend_restore_error_handling(&zeh);
848 }
849 }
850 }
851
852 static zval *column_at(zval *row, int col)
853 {
854 zval *data = NULL;
855 HashTable *ht = HASH_OF(row);
856 int count = zend_hash_num_elements(ht);
857
858 if (col >= count) {
859 php_error_docref(NULL, E_WARNING, "Column index %d exceeds column count %d", col, count);
860 } else {
861 zend_hash_internal_pointer_reset(ht);
862 while (col-- > 0) {
863 zend_hash_move_forward(ht);
864 }
865 data = zend_hash_get_current_data(ht);
866 }
867 return data;
868 }
869
870 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_col, 0, 0, 1)
871 ZEND_ARG_INFO(1, ref)
872 ZEND_ARG_INFO(0, col)
873 ZEND_END_ARG_INFO();
874 static PHP_METHOD(pqres, fetchCol) {
875 zend_error_handling zeh;
876 zval *zcol = NULL, *zref;
877 ZEND_RESULT_CODE rv;
878
879 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
880 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "z|z/!", &zref, &zcol);
881 zend_restore_error_handling(&zeh);
882
883 if (SUCCESS == rv) {
884 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
885
886 if (!obj->intern) {
887 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
888 } else {
889 zval row;
890
891 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
892 if (SUCCESS == php_pqres_iteration(getThis(), obj, php_pqres_fetch_type(obj->intern), &row)) {
893 php_pqres_col_t col;
894
895 if (SUCCESS != column_nn(obj, zcol, &col)) {
896 RETVAL_FALSE;
897 } else {
898 zval *zres = column_at(&row, col.num);
899
900 if (!zres) {
901 RETVAL_FALSE;
902 } else {
903 ZVAL_DEREF(zref);
904 zval_dtor(zref);
905 ZVAL_ZVAL(zref, zres, 1, 0);
906 RETVAL_TRUE;
907 }
908 }
909 }
910 zend_restore_error_handling(&zeh);
911 }
912 }
913 }
914
915 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_all_cols, 0, 0, 0)
916 ZEND_ARG_INFO(0, col)
917 ZEND_END_ARG_INFO();
918 static PHP_METHOD(pqres, fetchAllCols) {
919 zend_error_handling zeh;
920 zval *zcol = NULL;
921 ZEND_RESULT_CODE rv;
922
923 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
924 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|z!", &zcol);
925 zend_restore_error_handling(&zeh);
926
927 if (SUCCESS == rv) {
928 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
929
930 if (!obj->intern) {
931 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
932 } else {
933 php_pqres_col_t col;
934
935 zend_replace_error_handling(EH_THROW, exce(EX_RUNTIME), &zeh);
936 if (SUCCESS == column_nn(obj, zcol, &col)) {
937 int r, rows = PQntuples(obj->intern->res);
938 zval tmp;
939
940 array_init(return_value);
941 for (r = 0; r < rows; ++r) {
942 add_next_index_zval(return_value, php_pqres_get_col(obj->intern, r, col.num, &tmp));
943 }
944 }
945 zend_restore_error_handling(&zeh);
946 }
947 }
948 }
949
950 struct apply_to_col_arg {
951 php_pqres_object_t *obj;
952 php_pqres_col_t *cols;
953 ZEND_RESULT_CODE status;
954 };
955
956 static int apply_to_col(zval *c, void *a)
957 {
958 struct apply_to_col_arg *arg = a;
959
960 if (SUCCESS != column_nn(arg->obj, c, arg->cols)) {
961 arg->status = FAILURE;
962 return ZEND_HASH_APPLY_STOP;
963 } else {
964 arg->status = SUCCESS;
965 ++arg->cols;
966 return ZEND_HASH_APPLY_KEEP;
967 }
968 }
969
970 static php_pqres_col_t *php_pqres_convert_to_cols(php_pqres_object_t *obj, HashTable *ht)
971 {
972 struct apply_to_col_arg arg = {NULL};
973 php_pqres_col_t *tmp;
974
975 arg.obj = obj;
976 arg.cols = ecalloc(zend_hash_num_elements(ht), sizeof(*tmp));
977 tmp = arg.cols;
978 zend_hash_apply_with_argument(ht, apply_to_col, &arg);
979
980 if (SUCCESS == arg.status) {
981 return tmp;
982 } else {
983 efree(tmp);
984 return NULL;
985 }
986 }
987
988 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_map, 0, 0, 0)
989 ZEND_ARG_INFO(0, keys)
990 ZEND_ARG_INFO(0, vals)
991 ZEND_ARG_INFO(0, fetch_type)
992 ZEND_END_ARG_INFO();
993 static PHP_METHOD(pqres, map) {
994 zend_error_handling zeh;
995 zval *zkeys = 0, *zvals = 0;
996 zend_long fetch_type = -1;
997 ZEND_RESULT_CODE rv;
998
999 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1000 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|z/!z/!l", &zkeys, &zvals, &fetch_type);
1001 zend_restore_error_handling(&zeh);
1002
1003 if (SUCCESS == rv) {
1004 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
1005
1006 if (!obj->intern) {
1007 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1008 } else {
1009 int ks = 0, vs = 0;
1010 php_pqres_col_t def = {PQfname(obj->intern->res, 0), 0}, *keys = NULL, *vals = NULL;
1011
1012 if (zkeys) {
1013 convert_to_array(zkeys);
1014
1015 if ((ks = zend_hash_num_elements(Z_ARRVAL_P(zkeys)))) {
1016 keys = php_pqres_convert_to_cols(obj, Z_ARRVAL_P(zkeys));
1017 } else {
1018 ks = 1;
1019 keys = &def;
1020 }
1021 } else {
1022 ks = 1;
1023 keys = &def;
1024 }
1025 if (zvals) {
1026 convert_to_array(zvals);
1027
1028 if ((vs = zend_hash_num_elements(Z_ARRVAL_P(zvals)))) {
1029 vals = php_pqres_convert_to_cols(obj, Z_ARRVAL_P(zvals));
1030 }
1031 }
1032
1033 if (fetch_type == -1) {
1034 fetch_type = php_pqres_fetch_type(obj->intern);
1035 }
1036
1037 if (keys) {
1038 int rows, r;
1039 zval *cur;
1040
1041 switch (fetch_type) {
1042 case PHP_PQRES_FETCH_ARRAY:
1043 case PHP_PQRES_FETCH_ASSOC:
1044 array_init(return_value);
1045 break;
1046 case PHP_PQRES_FETCH_OBJECT:
1047 object_init(return_value);
1048 break;
1049 }
1050 for (r = 0, rows = PQntuples(obj->intern->res); r < rows; ++r) {
1051 int k, v;
1052 zval *ptr;
1053
1054 cur = return_value;
1055 for (k = 0; k < ks; ++k) {
1056 char *key = PQgetvalue(obj->intern->res, r, keys[k].num);
1057 int len = PQgetlength(obj->intern->res, r, keys[k].num);
1058
1059 if (!(ptr = zend_symtable_str_find(HASH_OF(cur), key, len))) {
1060 zval tmp;
1061
1062 switch (fetch_type) {
1063 case PHP_PQRES_FETCH_ARRAY:
1064 case PHP_PQRES_FETCH_ASSOC:
1065 array_init(&tmp);
1066 break;
1067 case PHP_PQRES_FETCH_OBJECT:
1068 object_init(&tmp);
1069 break;
1070 }
1071 if (!(ptr = zend_symtable_str_update(HASH_OF(cur), key, len, &tmp))) {
1072 throw_exce(EX_RUNTIME, "Failed to create map");
1073 goto err;
1074 }
1075 cur = ptr;
1076 }
1077 cur = ptr;
1078 }
1079 if (vals && vs) {
1080 for (v = 0; v < vs; ++v) {
1081 char *val = PQgetvalue(obj->intern->res, r, vals[v].num);
1082 int len = PQgetlength(obj->intern->res, r, vals[v].num);
1083
1084 switch (fetch_type) {
1085 case PHP_PQRES_FETCH_ARRAY:
1086 add_index_stringl(cur, vals[v].num, val, len);
1087 break;
1088 case PHP_PQRES_FETCH_ASSOC:
1089 add_assoc_stringl(cur, vals[v].name, val, len);
1090 break;
1091 case PHP_PQRES_FETCH_OBJECT:
1092 add_property_stringl(cur, vals[v].name, val, len);
1093 break;
1094 }
1095 }
1096 } else {
1097 php_pqres_row_to_zval(obj->intern->res, r, fetch_type, cur);
1098 }
1099 }
1100 }
1101
1102 err:
1103 if (keys && keys != &def) {
1104 efree(keys);
1105 }
1106 if (vals) {
1107 efree(vals);
1108 }
1109 }
1110 }
1111 }
1112
1113 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch_all, 0, 0, 0)
1114 ZEND_ARG_INFO(0, fetch_type)
1115 ZEND_END_ARG_INFO();
1116 static PHP_METHOD(pqres, fetchAll) {
1117 zend_error_handling zeh;
1118 zend_long fetch_type = -1;
1119 ZEND_RESULT_CODE rv;
1120
1121 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1122 rv = zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &fetch_type);
1123 zend_restore_error_handling(&zeh);
1124
1125 if (SUCCESS == rv) {
1126 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
1127
1128 if (!obj->intern) {
1129 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1130 } else {
1131 int r, rows = PQntuples(obj->intern->res);
1132 zval tmp;
1133
1134 if (fetch_type == -1) {
1135 fetch_type = php_pqres_fetch_type(obj->intern);
1136 }
1137
1138 array_init(return_value);
1139 for (r = 0; r < rows; ++r) {
1140 ZVAL_NULL(&tmp);
1141 add_next_index_zval(return_value, php_pqres_row_to_zval(obj->intern->res, r, fetch_type, &tmp));
1142 }
1143 }
1144 }
1145 }
1146
1147 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_count, 0, 0, 0)
1148 ZEND_END_ARG_INFO();
1149 static PHP_METHOD(pqres, count) {
1150 zend_error_handling zeh;
1151 ZEND_RESULT_CODE rv;
1152
1153 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1154 rv = zend_parse_parameters_none();
1155 zend_restore_error_handling(&zeh);
1156
1157 if (SUCCESS == rv) {
1158 long count;
1159
1160 if (SUCCESS != php_pqres_count_elements_70(getThis(), &count)) {
1161 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1162 } else {
1163 RETVAL_LONG(count);
1164 }
1165 }
1166 }
1167
1168 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_desc, 0, 0, 0)
1169 ZEND_END_ARG_INFO();
1170 static PHP_METHOD(pqres, desc) {
1171 zend_error_handling zeh;
1172 ZEND_RESULT_CODE rv;
1173
1174 zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
1175 rv = zend_parse_parameters_none();
1176 zend_restore_error_handling(&zeh);
1177
1178 if (SUCCESS == rv) {
1179 php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
1180
1181 if (!obj->intern) {
1182 throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
1183 } else {
1184 int p, params;
1185
1186 array_init(return_value);
1187 for (p = 0, params = PQnparams(obj->intern->res); p < params; ++p) {
1188 add_next_index_long(return_value, PQparamtype(obj->intern->res, p));
1189 }
1190 }
1191 }
1192 }
1193
1194 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_getIterator, 0, 0, 0)
1195 ZEND_END_ARG_INFO();
1196 static PHP_METHOD(pqres, getIterator)
1197 {
1198 ZEND_PARSE_PARAMETERS_NONE();
1199 zend_create_internal_iterator_zval(return_value, ZEND_THIS);
1200 }
1201
1202 static zend_function_entry php_pqres_methods[] = {
1203 PHP_ME(pqres, bind, ai_pqres_bind, ZEND_ACC_PUBLIC)
1204 PHP_ME(pqres, fetchBound, ai_pqres_fetch_bound, ZEND_ACC_PUBLIC)
1205 PHP_ME(pqres, fetchRow, ai_pqres_fetch_row, ZEND_ACC_PUBLIC)
1206 PHP_ME(pqres, fetchCol, ai_pqres_fetch_col, ZEND_ACC_PUBLIC)
1207 PHP_ME(pqres, fetchAll, ai_pqres_fetch_all, ZEND_ACC_PUBLIC)
1208 PHP_ME(pqres, fetchAllCols, ai_pqres_fetch_all_cols, ZEND_ACC_PUBLIC)
1209 PHP_ME(pqres, count, ai_pqres_count, ZEND_ACC_PUBLIC)
1210 PHP_ME(pqres, map, ai_pqres_map, ZEND_ACC_PUBLIC)
1211 PHP_ME(pqres, desc, ai_pqres_desc, ZEND_ACC_PUBLIC)
1212 PHP_ME(pqres, getIterator, ai_pqres_getIterator, ZEND_ACC_PUBLIC)
1213 {0}
1214 };
1215
1216 PHP_MSHUTDOWN_FUNCTION(pqres)
1217 {
1218 zend_hash_destroy(&php_pqres_object_prophandlers);
1219 return SUCCESS;
1220 }
1221
1222 PHP_MINIT_FUNCTION(pqres)
1223 {
1224 zend_class_entry ce = {0};
1225 php_pq_object_prophandler_t ph = {0};
1226
1227 INIT_NS_CLASS_ENTRY(ce, "pq", "Result", php_pqres_methods);
1228 php_pqres_class_entry = zend_register_internal_class_ex(&ce, NULL);
1229 php_pqres_class_entry->create_object = php_pqres_create_object;
1230 php_pqres_class_entry->get_iterator = php_pqres_iterator_init;
1231 zend_class_implements(php_pqres_class_entry, 2, zend_ce_aggregate, spl_ce_Countable);
1232
1233 memcpy(&php_pqres_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1234 php_pqres_object_handlers.offset = XtOffsetOf(php_pqres_object_t, zo);
1235 php_pqres_object_handlers.free_obj = php_pqres_object_free;
1236 php_pqres_object_handlers.read_property = php_pq_object_read_prop;
1237 php_pqres_object_handlers.write_property = php_pq_object_write_prop;
1238 php_pqres_object_handlers.clone_obj = NULL;
1239 php_pqres_object_handlers.get_property_ptr_ptr = php_pq_object_get_prop_ptr_null;
1240 php_pqres_object_handlers.get_gc = php_pq_object_get_gc;
1241 php_pqres_object_handlers.get_debug_info = php_pq_object_debug_info;
1242 php_pqres_object_handlers.get_properties = php_pq_object_properties;
1243 php_pqres_object_handlers.count_elements = php_pqres_count_elements;
1244
1245 zend_hash_init(&php_pqres_object_prophandlers, 9, NULL, php_pq_object_prophandler_dtor, 1);
1246
1247 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("status"), ZEND_ACC_PUBLIC);
1248 ph.read = php_pqres_object_read_status;
1249 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "status", sizeof("status")-1, (void *) &ph, sizeof(ph));
1250
1251 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("statusMessage"), ZEND_ACC_PUBLIC);
1252 ph.read = php_pqres_object_read_status_message;
1253 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "statusMessage", sizeof("statusMessage")-1, (void *) &ph, sizeof(ph));
1254
1255 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("errorMessage"), ZEND_ACC_PUBLIC);
1256 ph.read = php_pqres_object_read_error_message;
1257 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "errorMessage", sizeof("errorMessage")-1, (void *) &ph, sizeof(ph));
1258
1259 zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("diag"), ZEND_ACC_PUBLIC);
1260 ph.read = php_pqres_object_read_diag;
1261 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "diag", sizeof("diag")-1, (void *) &ph, sizeof(ph));
1262
1263 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("numRows"), 0, ZEND_ACC_PUBLIC);
1264 ph.read = php_pqres_object_read_num_rows;
1265 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "numRows", sizeof("numRows")-1, (void *) &ph, sizeof(ph));
1266
1267 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("numCols"), 0, ZEND_ACC_PUBLIC);
1268 ph.read = php_pqres_object_read_num_cols;
1269 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "numCols", sizeof("numCols")-1, (void *) &ph, sizeof(ph));
1270
1271 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("affectedRows"), 0, ZEND_ACC_PUBLIC);
1272 ph.read = php_pqres_object_read_affected_rows;
1273 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "affectedRows", sizeof("affectedRows")-1, (void *) &ph, sizeof(ph));
1274
1275 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("fetchType"), PHP_PQRES_FETCH_ARRAY, ZEND_ACC_PUBLIC);
1276 ph.read = php_pqres_object_read_fetch_type;
1277 ph.write = php_pqres_object_write_fetch_type;
1278 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "fetchType", sizeof("fetchType")-1, (void *) &ph, sizeof(ph));
1279 ph.write = NULL;
1280
1281 zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("autoConvert"), PHP_PQRES_CONV_ALL, ZEND_ACC_PUBLIC);
1282 ph.read = php_pqres_object_read_auto_conv;
1283 ph.write = php_pqres_object_write_auto_conv;
1284 zend_hash_str_add_mem(&php_pqres_object_prophandlers, "autoConvert", sizeof("autoConvert")-1, (void *) &ph, sizeof(ph));
1285 ph.write = NULL;
1286
1287 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("EMPTY_QUERY"), PGRES_EMPTY_QUERY);
1288 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COMMAND_OK"), PGRES_COMMAND_OK);
1289 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("TUPLES_OK"), PGRES_TUPLES_OK);
1290 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_OUT"), PGRES_COPY_OUT);
1291 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_IN"), PGRES_COPY_IN);
1292 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("BAD_RESPONSE"), PGRES_BAD_RESPONSE);
1293 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("NONFATAL_ERROR"), PGRES_NONFATAL_ERROR);
1294 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FATAL_ERROR"), PGRES_FATAL_ERROR);
1295 #ifdef HAVE_PGRES_COPY_BOTH
1296 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_BOTH"), PGRES_COPY_BOTH);
1297 #endif
1298 #ifdef HAVE_PGRES_SINGLE_TUPLE
1299 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("SINGLE_TUPLE"), PGRES_SINGLE_TUPLE);
1300 #endif
1301
1302 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FETCH_ARRAY"), PHP_PQRES_FETCH_ARRAY);
1303 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FETCH_ASSOC"), PHP_PQRES_FETCH_ASSOC);
1304 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FETCH_OBJECT"), PHP_PQRES_FETCH_OBJECT);
1305
1306 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_BOOL"), PHP_PQRES_CONV_BOOL);
1307 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_INT"), PHP_PQRES_CONV_INT);
1308 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_FLOAT"), PHP_PQRES_CONV_FLOAT);
1309 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_SCALAR"), PHP_PQRES_CONV_SCALAR);
1310 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_ARRAY"), PHP_PQRES_CONV_ARRAY);
1311 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_DATETIME"), PHP_PQRES_CONV_DATETIME);
1312 #if PHP_PQ_HAVE_PHP_JSON_H
1313 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_JSON"), PHP_PQRES_CONV_JSON);
1314 #endif
1315 zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_ALL"), PHP_PQRES_CONV_ALL);
1316
1317 return SUCCESS;
1318 }
1319
1320 /*
1321 * Local variables:
1322 * tab-width: 4
1323 * c-basic-offset: 4
1324 * End:
1325 * vim600: noet sw=4 ts=4 fdm=marker
1326 * vim<600: noet sw=4 ts=4
1327 */
PostgreSQL client library (libpq) binding