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