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