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