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