git.m6w6.name Git - m6w6/ext-pq/blob - src/php_pq.c

   1 /*
   2   +----------------------------------------------------------------------+
   3   | PHP Version 5                                                        |
   4   +----------------------------------------------------------------------+
   5   | Copyright (c) 1997-2012 The PHP Group                                |
   6   +----------------------------------------------------------------------+
   7   | This source file is subject to version 3.01 of the PHP license,      |
   8   | that is bundled with this package in the file LICENSE, and is        |
   9   | available through the world-wide-web at the following url:           |
  10   | http://www.php.net/license/3_01.txt                                  |
  11   | If you did not receive a copy of the PHP license and are unable to   |
  12   | obtain it through the world-wide-web, please send a note to          |
  13   | license@php.net so we can mail you a copy immediately.               |
  14   +----------------------------------------------------------------------+
  15   | Author:                                                              |
  16   +----------------------------------------------------------------------+
  17 */
  18
  19 /* $Id$ */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #       include "config.h"
  23 #endif
  24
  25 #include "php.h"
  26 #include "ext/standard/info.h"
  27 #include "php_pq.h"
  28 #include <libpq-events.h>
  29
  30 typedef int STATUS; /* SUCCESS/FAILURE */
  31
  32 /*
  33 ZEND_DECLARE_MODULE_GLOBALS(pq)
  34 */
  35
  36 const zend_function_entry pq_functions[] = {
  37         {0}
  38 };
  39
  40 /* {{{ pq_module_entry
  41  */
  42 zend_module_entry pq_module_entry = {
  43         STANDARD_MODULE_HEADER,
  44         "pq",
  45         pq_functions,
  46         PHP_MINIT(pq),
  47         PHP_MSHUTDOWN(pq),
  48         NULL,/*PHP_RINIT(pq),*/
  49         NULL,/*PHP_RSHUTDOWN(pq),*/
  50         PHP_MINFO(pq),
  51         PHP_PQ_EXT_VERSION,
  52         STANDARD_MODULE_PROPERTIES
  53 };
  54 /* }}} */
  55
  56 #ifdef COMPILE_DL_PQ
  57 ZEND_GET_MODULE(pq)
  58 #endif
  59
  60 /* {{{ PHP_INI
  61  */
  62 /* Remove comments and fill if you need to have entries in php.ini
  63 PHP_INI_BEGIN()
  64     STD_PHP_INI_ENTRY("pq.global_value",      "42", PHP_INI_ALL, OnUpdateLong, global_value, zend_pq_globals, pq_globals)
  65     STD_PHP_INI_ENTRY("pq.global_string", "foobar", PHP_INI_ALL, OnUpdateString, global_string, zend_pq_globals, pq_globals)
  66 PHP_INI_END()
  67 */
  68 /* }}} */
  69
  70 /* {{{ php_pq_init_globals
  71  */
  72 /* Uncomment this function if you have INI entries
  73 static void php_pq_init_globals(zend_pq_globals *pq_globals)
  74 {
  75         pq_globals->global_value = 0;
  76         pq_globals->global_string = NULL;
  77 }
  78 */
  79 /* }}} */
  80
  81 static zend_class_entry *php_pqconn_class_entry;
  82 static zend_class_entry *php_pqres_class_entry;
  83
  84 static zend_object_handlers php_pqconn_object_handlers;
  85 static zend_object_handlers php_pqres_object_handlers;
  86
  87 typedef struct php_pqconn_object {
  88         zend_object zo;
  89         PGconn *conn;
  90         int (*poller)(PGconn *);
  91         unsigned blocking:1;
  92 } php_pqconn_object_t;
  93
  94 typedef struct php_pqres_object {
  95         zend_object zo;
  96         PGresult *res;
  97 } php_pqres_object_t;
  98
  99 typedef enum php_pqres_fetch {
 100         PHP_PQRES_FETCH_ARRAY,
 101         PHP_PQRES_FETCH_ASSOC,
 102         PHP_PQRES_FETCH_OBJECT
 103 } php_pqres_fetch_t;
 104
 105 static void php_pqconn_object_free(void *o TSRMLS_DC)
 106 {
 107         php_pqconn_object_t *obj = o;
 108
 109         if (obj->conn) {
 110                 PQfinish(obj->conn);
 111                 obj->conn = NULL;
 112         }
 113         zend_object_std_dtor((zend_object *) o TSRMLS_CC);
 114         efree(obj);
 115 }
 116
 117 static void php_pqres_object_free(void *o TSRMLS_DC)
 118 {
 119         php_pqres_object_t *obj = o;
 120
 121         if (obj->res) {
 122                 PQclear(obj->res);
 123                 obj->res = NULL;
 124         }
 125         zend_object_std_dtor((zend_object *) o TSRMLS_CC);
 126         efree(obj);
 127 }
 128
 129 static zend_object_value php_pqconn_create_object_ex(zend_class_entry *ce, PGconn *conn, php_pqconn_object_t **ptr TSRMLS_DC)
 130 {
 131         zend_object_value ov;
 132         php_pqconn_object_t *o;
 133
 134         o = ecalloc(1, sizeof(*o));
 135         zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
 136         object_properties_init((zend_object *) o, ce);
 137
 138         if (ptr) {
 139                 *ptr = o;
 140         }
 141
 142         if (conn) {
 143                 o->conn = conn;
 144                 o->blocking = !PQisnonblocking(o->conn);
 145         }
 146
 147         ov.handle = zend_objects_store_put((zend_object *) o, NULL, php_pqconn_object_free, NULL TSRMLS_CC);
 148         ov.handlers = &php_pqconn_object_handlers;
 149
 150         return ov;
 151 }
 152
 153 static zend_object_value php_pqres_create_object_ex(zend_class_entry *ce, PGresult *res, php_pqres_object_t **ptr TSRMLS_DC)
 154 {
 155         zend_object_value ov;
 156         php_pqres_object_t *o;
 157
 158         o = ecalloc(1, sizeof(*o));
 159         zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
 160         object_properties_init((zend_object *) o, ce);
 161
 162         if (ptr) {
 163                 *ptr = o;
 164         }
 165
 166         if (res) {
 167                 o->res = res;
 168         }
 169
 170         ov.handle = zend_objects_store_put((zend_object *) o, NULL, php_pqres_object_free, NULL TSRMLS_CC);
 171         ov.handlers = &php_pqres_object_handlers;
 172
 173         return ov;
 174 }
 175
 176 static zend_object_value php_pqconn_create_object(zend_class_entry *class_type TSRMLS_DC)
 177 {
 178         return php_pqconn_create_object_ex(class_type, NULL, NULL TSRMLS_CC);
 179 }
 180
 181 static zend_object_value php_pqres_create_object(zend_class_entry *class_type TSRMLS_DC)
 182 {
 183         return php_pqres_create_object_ex(class_type, NULL, NULL TSRMLS_CC);
 184 }
 185
 186 static HashTable php_pqconn_object_prophandlers;
 187 static HashTable php_pqres_object_prophandlers;
 188
 189 typedef void (*php_pq_object_prophandler_func_t)(void *o, zval *return_value TSRMLS_DC);
 190
 191 typedef struct php_pq_object_prophandler {
 192         php_pq_object_prophandler_func_t read;
 193         php_pq_object_prophandler_func_t write;
 194 } php_pq_object_prophandler_t;
 195
 196 static void php_pqconn_object_read_status(void *o, zval *return_value TSRMLS_DC)
 197 {
 198         php_pqconn_object_t *obj = o;
 199
 200         RETVAL_LONG(PQstatus(obj->conn));
 201 }
 202
 203 static void php_pqconn_object_read_transaction_status(void *o, zval *return_value TSRMLS_DC)
 204 {
 205         php_pqconn_object_t *obj = o;
 206
 207         RETVAL_LONG(PQtransactionStatus(obj->conn));
 208 }
 209
 210 static void php_pqconn_object_read_socket(void *o, zval *return_value TSRMLS_DC)
 211 {
 212         php_pqconn_object_t *obj = o;
 213         php_stream *stream;
 214         int socket = PQsocket(obj->conn);
 215
 216         if ((stream = php_stream_fopen_from_fd(socket, "r+b", NULL))) {
 217                 php_stream_to_zval(stream, return_value);
 218         } else {
 219                 RETVAL_NULL();
 220         }
 221 }
 222
 223 static void php_pqconn_object_read_error_message(void *o, zval *return_value TSRMLS_DC)
 224 {
 225         php_pqconn_object_t *obj = o;
 226         char *error = PQerrorMessage(obj->conn);
 227
 228         if (error) {
 229                 RETVAL_STRING(error, 1);
 230         } else {
 231                 RETVAL_NULL();
 232         }
 233 }
 234
 235 static void php_pqres_object_read_status(void *o, zval *return_value TSRMLS_DC)
 236 {
 237         php_pqres_object_t *obj = o;
 238
 239         RETVAL_LONG(PQresultStatus(obj->res));
 240 }
 241
 242 static void php_pqres_object_read_error_message(void *o, zval *return_value TSRMLS_DC)
 243 {
 244         php_pqres_object_t *obj = o;
 245         char *error = PQresultErrorMessage(obj->res);
 246
 247         if (error) {
 248                 RETVAL_STRING(error, 1);
 249         } else {
 250                 RETVAL_NULL();
 251         }
 252 }
 253
 254 static void php_pqres_object_read_num_rows(void *o, zval *return_value TSRMLS_DC)
 255 {
 256         php_pqres_object_t *obj = o;
 257
 258         RETVAL_LONG(PQntuples(obj->res));
 259 }
 260
 261 static void php_pqres_object_read_num_cols(void *o, zval *return_value TSRMLS_DC)
 262 {
 263         php_pqres_object_t *obj = o;
 264
 265         RETVAL_LONG(PQnfields(obj->res));
 266 }
 267
 268 static void php_pqres_object_read_affected_rows(void *o, zval *return_value TSRMLS_DC)
 269 {
 270         php_pqres_object_t *obj = o;
 271
 272         RETVAL_LONG(atoi(PQcmdTuples(obj->res)));
 273 }
 274
 275 static zval *php_pqconn_object_read_prop(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
 276 {
 277         php_pqconn_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
 278         php_pq_object_prophandler_t *handler;
 279         zval *return_value;
 280
 281         if (!obj->conn) {
 282                 zend_error(E_WARNING, "Connection not initialized");
 283         } else if (SUCCESS == zend_hash_find(&php_pqconn_object_prophandlers, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void *) &handler)) {
 284                 if (type == BP_VAR_R) {
 285                         ALLOC_ZVAL(return_value);
 286                         Z_SET_REFCOUNT_P(return_value, 0);
 287                         Z_UNSET_ISREF_P(return_value);
 288
 289                         handler->read(obj, return_value TSRMLS_CC);
 290                 } else {
 291                         zend_error(E_ERROR, "Cannot access pq\\Connection properties by reference or array key/index");
 292                         return_value = NULL;
 293                 }
 294         } else {
 295                 return_value = zend_get_std_object_handlers()->read_property(object, member, type, key TSRMLS_CC);
 296         }
 297
 298         return return_value;
 299 }
 300
 301 static void php_pqconn_object_write_prop(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
 302 {
 303         php_pqconn_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
 304         php_pq_object_prophandler_t *handler;
 305
 306         if (zend_hash_find(&php_pqconn_object_prophandlers, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void *) &handler)) {
 307                 if (handler->write) {
 308                         handler->write(obj, value TSRMLS_CC);
 309                 }
 310         } else {
 311                 zend_get_std_object_handlers()->write_property(object, member, value, key TSRMLS_CC);
 312         }
 313 }
 314
 315 static zval *php_pqres_object_read_prop(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
 316 {
 317         php_pqres_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
 318         php_pq_object_prophandler_t *handler;
 319         zval *return_value;
 320
 321         if (!obj->res) {
 322                 zend_error(E_WARNING, "Result not initialized");
 323         } else if (SUCCESS == zend_hash_find(&php_pqres_object_prophandlers, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void *) &handler)) {
 324                 if (type == BP_VAR_R) {
 325                         ALLOC_ZVAL(return_value);
 326                         Z_SET_REFCOUNT_P(return_value, 0);
 327                         Z_UNSET_ISREF_P(return_value);
 328
 329                         handler->read(obj, return_value TSRMLS_CC);
 330                 } else {
 331                         zend_error(E_ERROR, "Cannot access pq\\Result properties by reference or array key/index");
 332                         return_value = NULL;
 333                 }
 334         } else {
 335                 return_value = zend_get_std_object_handlers()->read_property(object, member, type, key TSRMLS_CC);
 336         }
 337
 338         return return_value;
 339 }
 340
 341 static void php_pqres_object_write_prop(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
 342 {
 343         php_pqres_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
 344         php_pq_object_prophandler_t *handler;
 345
 346         if (!obj->res) {
 347                 zend_error(E_WARNING, "Result not initialized");
 348         } else if (zend_hash_find(&php_pqres_object_prophandlers, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void *) &handler)) {
 349                 if (handler->write) {
 350                         handler->write(obj, value TSRMLS_CC);
 351                 }
 352         } else {
 353                 zend_get_std_object_handlers()->write_property(object, member, value, key TSRMLS_CC);
 354         }
 355 }
 356
 357 typedef struct php_pqres_iterator {
 358         zend_object_iterator zi;
 359         zval *current_val;
 360         unsigned index;
 361 } php_pqres_iterator_t;
 362
 363 static zend_object_iterator_funcs php_pqres_iterator_funcs;
 364
 365 static zend_object_iterator *php_pqres_iterator_init(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
 366 {
 367         php_pqres_iterator_t *iter;
 368
 369         iter = ecalloc(1, sizeof(*iter));
 370         iter->zi.funcs = &php_pqres_iterator_funcs;
 371         iter->zi.data = object;
 372         Z_ADDREF_P(object);
 373
 374         return (zend_object_iterator *) iter;
 375 }
 376
 377 static void php_pqres_iterator_dtor(zend_object_iterator *i TSRMLS_DC)
 378 {
 379         php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
 380
 381         if (iter->current_val) {
 382                 zval_ptr_dtor(&iter->current_val);
 383         }
 384         zval_ptr_dtor((zval **) &iter->zi.data);
 385         efree(iter);
 386 }
 387
 388 static STATUS php_pqres_iterator_valid(zend_object_iterator *i TSRMLS_DC)
 389 {
 390         php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
 391         php_pqres_object_t *obj = zend_object_store_get_object(iter->zi.data TSRMLS_CC);
 392
 393         if (PQresultStatus(obj->res) != PGRES_TUPLES_OK) {
 394                 return FAILURE;
 395         }
 396         if (PQntuples(obj->res) <= iter->index) {
 397                 return FAILURE;
 398         }
 399
 400         return SUCCESS;
 401 }
 402
 403 static zval *php_pqres_row_to_zval(PGresult *res, unsigned row)
 404 {
 405         zval *data;
 406         int c, cols;
 407
 408         MAKE_STD_ZVAL(data);
 409         array_init(data);
 410
 411         for (c = 0, cols = PQnfields(res); c < cols; ++c) {
 412                 if (PQgetisnull(res, row, c)) {
 413                         add_index_null(data, c);
 414                         add_assoc_null(data, PQfname(res, c));
 415                 } else {
 416                         char *val = PQgetvalue(res, row, c);
 417                         int len = PQgetlength(res, row, c);
 418
 419                         add_index_stringl(data, c, val, len ,1);
 420                         add_assoc_stringl(data, PQfname(res, c), val, len, 1);
 421                 }
 422         }
 423
 424         return data;
 425 }
 426
 427 static void php_pqres_iterator_current(zend_object_iterator *i, zval ***data_ptr TSRMLS_DC)
 428 {
 429         php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
 430         php_pqres_object_t *obj = zend_object_store_get_object(iter->zi.data TSRMLS_CC);
 431
 432         if (iter->current_val) {
 433                 zval_ptr_dtor(&iter->current_val);
 434         }
 435         iter->current_val = php_pqres_row_to_zval(obj->res, iter->index);
 436         *data_ptr = &iter->current_val;
 437 }
 438
 439 static int php_pqres_iterator_key(zend_object_iterator *i, char **key_str, uint *key_len, ulong *key_num TSRMLS_DC)
 440 {
 441         php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
 442
 443         *key_num = (ulong) iter->index;
 444
 445         return HASH_KEY_IS_LONG;
 446 }
 447
 448 static void php_pqres_iterator_next(zend_object_iterator *i TSRMLS_DC)
 449 {
 450         php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
 451
 452         ++iter->index;
 453 }
 454
 455 static void php_pqres_iterator_rewind(zend_object_iterator *i TSRMLS_DC)
 456 {
 457         php_pqres_iterator_t *iter = (php_pqres_iterator_t *) i;
 458
 459         iter->index = 0;
 460 }
 461
 462 static zend_object_iterator_funcs php_pqres_iterator_funcs = {
 463         php_pqres_iterator_dtor,
 464         /* check for end of iteration (FAILURE or SUCCESS if data is valid) */
 465         php_pqres_iterator_valid,
 466         /* fetch the item data for the current element */
 467         php_pqres_iterator_current,
 468         /* fetch the key for the current element (return HASH_KEY_IS_STRING or HASH_KEY_IS_LONG) (optional, may be NULL) */
 469         php_pqres_iterator_key,
 470         /* step forwards to next element */
 471         php_pqres_iterator_next,
 472         /* rewind to start of data (optional, may be NULL) */
 473         php_pqres_iterator_rewind,
 474         /* invalidate current value/key (optional, may be NULL) */
 475         NULL
 476 };
 477
 478 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_construct, 0, 0, 1)
 479         ZEND_ARG_INFO(0, dsn)
 480         ZEND_ARG_INFO(0, block)
 481 ZEND_END_ARG_INFO();
 482 static PHP_METHOD(pqconn, __construct) {
 483         zend_error_handling zeh;
 484         char *dsn_str;
 485         int dsn_len;
 486         zend_bool block = 1;
 487
 488         zend_replace_error_handling(EH_THROW, NULL, &zeh TSRMLS_CC);
 489         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &dsn_str, &dsn_len, &block)) {
 490                 php_pqconn_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 491
 492                 if (obj->conn) {
 493                         PQfinish(obj->conn);
 494                 }
 495                 if ((obj->blocking = block)) {
 496                         obj->conn = PQconnectdb(dsn_str);
 497                 } else {
 498                         obj->conn = PQconnectStart(dsn_str);
 499                         obj->poller = (int (*)(PGconn*)) PQconnectPoll;
 500                 }
 501
 502                 if (CONNECTION_BAD == PQstatus(obj->conn)) {
 503                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection failed: %s", PQerrorMessage(obj->conn));
 504                 }
 505         }
 506         zend_restore_error_handling(&zeh TSRMLS_CC);
 507 }
 508
 509 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_reset, 0, 0, 0)
 510 ZEND_END_ARG_INFO();
 511 static PHP_METHOD(pqconn, reset) {
 512         if (SUCCESS == zend_parse_parameters_none()) {
 513                 php_pqconn_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 514
 515                 if (obj->conn) {
 516                         if (obj->blocking) {
 517                                 PQreset(obj->conn);
 518                                 RETURN_TRUE; /* probably ;) */
 519                         } if (PQresetStart(obj->conn)) {
 520                                 obj->poller = (int (*)(PGconn*)) PQresetPoll;
 521                                 RETURN_TRUE;
 522                         }
 523                 } else {
 524                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not initialized");
 525                 }
 526                 RETURN_FALSE;
 527         }
 528 }
 529
 530 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_poll, 0, 0, 0)
 531 ZEND_END_ARG_INFO();
 532 static PHP_METHOD(pqconn, poll) {
 533         if (SUCCESS == zend_parse_parameters_none()) {
 534                 php_pqconn_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 535
 536                 if (obj->conn) {
 537                         if (obj->poller) {
 538                                 RETURN_LONG(obj->poller(obj->conn));
 539                         } else {
 540                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "No asynchronous operation active");
 541                         }
 542                 } else {
 543                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not initialized");
 544                 }
 545                 RETURN_FALSE;
 546         }
 547 }
 548
 549 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_exec, 0, 0, 1)
 550         ZEND_ARG_INFO(0, query)
 551 ZEND_END_ARG_INFO();
 552 static PHP_METHOD(pqconn, exec) {
 553         zend_error_handling zeh;
 554         char *query_str;
 555         int query_len;
 556
 557         zend_replace_error_handling(EH_THROW, NULL, &zeh TSRMLS_CC);
 558         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &query_str, &query_len)) {
 559                 php_pqconn_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 560
 561                 if (obj->conn) {
 562                         PGresult *res = PQexec(obj->conn, query_str);
 563
 564                         if (res) {
 565                                 return_value->type = IS_OBJECT;
 566                                 return_value->value.obj = php_pqres_create_object_ex(php_pqres_class_entry, res, NULL TSRMLS_CC);
 567                         } else {
 568                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute query: %s", PQerrorMessage(obj->conn));
 569                         }
 570                 } else {
 571                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not initialized");
 572                 }
 573         }
 574         zend_restore_error_handling(&zeh TSRMLS_CC);
 575 }
 576
 577 static zend_function_entry pqconn_methods[] = {
 578         PHP_ME(pqconn, __construct, ai_pqconn_construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 579         PHP_ME(pqconn, reset, ai_pqconn_reset, ZEND_ACC_PUBLIC)
 580         PHP_ME(pqconn, poll, ai_pqconn_poll, ZEND_ACC_PUBLIC)
 581         PHP_ME(pqconn, exec, ai_pqconn_exec, ZEND_ACC_PUBLIC)
 582         {0}
 583 };
 584
 585 ZEND_BEGIN_ARG_INFO_EX(ai_pqres_fetch, 0, 0, 0)
 586         ZEND_ARG_INFO(0, fetch_type)
 587         ZEND_ARG_INFO(0, fetch_info)
 588 ZEND_END_ARG_INFO();
 589 static PHP_METHOD(pqres, fetchRow) {
 590         zend_error_handling zeh;
 591         long fetch_type = PHP_PQRES_FETCH_OBJECT;
 592         zval *fetch_info = NULL;
 593
 594         zend_replace_error_handling(EH_THROW, NULL, &zeh TSRMLS_CC);
 595         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lz", &fetch_type, &fetch_info)) {
 596
 597         }
 598         zend_restore_error_handling(&zeh TSRMLS_CC);
 599 }
 600
 601 static zend_function_entry pqres_methods[] = {
 602         PHP_ME(pqres, fetchRow, ai_pqres_fetch, ZEND_ACC_PUBLIC)
 603         {0}
 604 };
 605
 606 /* {{{ PHP_MINIT_FUNCTION
 607  */
 608 PHP_MINIT_FUNCTION(pq)
 609 {
 610         zend_class_entry ce = {0};
 611         php_pq_object_prophandler_t ph = {0};
 612
 613         zend_hash_init(&php_pqconn_object_prophandlers, 1, NULL, NULL, 1);
 614         INIT_NS_CLASS_ENTRY(ce, "pq", "Connection", pqconn_methods);
 615         php_pqconn_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
 616         php_pqconn_class_entry->create_object = php_pqconn_create_object;
 617         memcpy(&php_pqconn_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 618         php_pqconn_object_handlers.read_property = php_pqconn_object_read_prop;
 619         php_pqconn_object_handlers.write_property = php_pqconn_object_write_prop;
 620
 621         zend_declare_property_long(php_pqconn_class_entry, ZEND_STRL("status"), CONNECTION_BAD, ZEND_ACC_PUBLIC TSRMLS_CC);
 622         ph.read = php_pqconn_object_read_status;
 623         zend_hash_add(&php_pqconn_object_prophandlers, "status", sizeof("status"), (void *) &ph, sizeof(ph), NULL);
 624
 625         zend_declare_property_long(php_pqconn_class_entry, ZEND_STRL("transactionStatus"), PQTRANS_UNKNOWN, ZEND_ACC_PUBLIC TSRMLS_CC);
 626         ph.read = php_pqconn_object_read_transaction_status;
 627         zend_hash_add(&php_pqconn_object_prophandlers, "transactionStatus", sizeof("transactionStatus"), (void *) &ph, sizeof(ph), NULL);
 628
 629         zend_declare_property_null(php_pqconn_class_entry, ZEND_STRL("socket"), ZEND_ACC_PUBLIC TSRMLS_CC);
 630         ph.read = php_pqconn_object_read_socket;
 631         zend_hash_add(&php_pqconn_object_prophandlers, "socket", sizeof("socket"), (void *) &ph, sizeof(ph), NULL);
 632
 633         zend_declare_property_null(php_pqconn_class_entry, ZEND_STRL("errorMessage"), ZEND_ACC_PUBLIC TSRMLS_CC);
 634         ph.read = php_pqconn_object_read_error_message;
 635         zend_hash_add(&php_pqconn_object_prophandlers, "errorMessage", sizeof("errorMessage"), (void *) &ph, sizeof(ph), NULL);
 636
 637         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("OK"), CONNECTION_OK TSRMLS_CC);
 638         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("BAD"), CONNECTION_BAD TSRMLS_CC);
 639         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("STARTED"), CONNECTION_STARTED TSRMLS_CC);
 640         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("MADE"), CONNECTION_MADE TSRMLS_CC);
 641         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("AWAITING_RESPONSE"), CONNECTION_AWAITING_RESPONSE TSRMLS_CC);
 642         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("AUTH_OK"), CONNECTION_AUTH_OK TSRMLS_CC);
 643         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("SSL_STARTUP"), CONNECTION_SSL_STARTUP TSRMLS_CC);
 644         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("SETENV"), CONNECTION_SETENV TSRMLS_CC);
 645
 646         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_IDLE"), PQTRANS_IDLE TSRMLS_CC);
 647         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_ACTIVE"), PQTRANS_ACTIVE TSRMLS_CC);
 648         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_INTRANS"), PQTRANS_INTRANS TSRMLS_CC);
 649         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_INERROR"), PQTRANS_INERROR TSRMLS_CC);
 650         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_UNKNOWN"), PQTRANS_UNKNOWN TSRMLS_CC);
 651
 652         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("POLLING_FAILED"), PGRES_POLLING_FAILED TSRMLS_CC);
 653         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("POLLING_READING"), PGRES_POLLING_READING TSRMLS_CC);
 654         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("POLLING_WRITING"), PGRES_POLLING_WRITING TSRMLS_CC);
 655         zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("POLLING_OK"), PGRES_POLLING_OK TSRMLS_CC);
 656
 657         zend_hash_init(&php_pqres_object_prophandlers, 1, NULL, NULL, 1);
 658         memset(&ce, 0, sizeof(ce));
 659         INIT_NS_CLASS_ENTRY(ce, "pq", "Result", pqres_methods);
 660         php_pqres_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
 661         php_pqres_class_entry->create_object = php_pqres_create_object;
 662         php_pqres_class_entry->iterator_funcs.funcs = &php_pqres_iterator_funcs;
 663         php_pqres_class_entry->get_iterator = php_pqres_iterator_init;
 664
 665         memcpy(&php_pqres_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 666         php_pqres_object_handlers.read_property = php_pqres_object_read_prop;
 667         php_pqres_object_handlers.write_property = php_pqres_object_write_prop;
 668
 669         zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("status"), ZEND_ACC_PUBLIC TSRMLS_CC);
 670         ph.read = php_pqres_object_read_status;
 671         zend_hash_add(&php_pqres_object_prophandlers, "status", sizeof("status"), (void *) &ph, sizeof(ph), NULL);
 672
 673         zend_declare_property_null(php_pqres_class_entry, ZEND_STRL("errorMessage"), ZEND_ACC_PUBLIC TSRMLS_CC);
 674         ph.read = php_pqres_object_read_error_message;
 675         zend_hash_add(&php_pqres_object_prophandlers, "errorMessage", sizeof("errorMessage"), (void *) &ph, sizeof(ph), NULL);
 676
 677         zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("numRows"), 0, ZEND_ACC_PUBLIC TSRMLS_CC);
 678         ph.read = php_pqres_object_read_num_rows;
 679         zend_hash_add(&php_pqres_object_prophandlers, "numRows", sizeof("numRows"), (void *) &ph, sizeof(ph), NULL);
 680
 681         zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("numCols"), 0, ZEND_ACC_PUBLIC TSRMLS_CC);
 682         ph.read = php_pqres_object_read_num_cols;
 683         zend_hash_add(&php_pqres_object_prophandlers, "numCols", sizeof("numCols"), (void *) &ph, sizeof(ph), NULL);
 684
 685         zend_declare_property_long(php_pqres_class_entry, ZEND_STRL("affectedRows"), 0, ZEND_ACC_PUBLIC TSRMLS_CC);
 686         ph.read = php_pqres_object_read_affected_rows;
 687         zend_hash_add(&php_pqres_object_prophandlers, "affectedRows", sizeof("affectedRows"), (void *) &ph, sizeof(ph), NULL);
 688
 689         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("EMPTY_QUERY"), PGRES_EMPTY_QUERY TSRMLS_CC);
 690         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COMMAND_OK"), PGRES_COMMAND_OK TSRMLS_CC);
 691         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("TUPLES_OK"), PGRES_TUPLES_OK TSRMLS_CC);
 692         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_OUT"), PGRES_COPY_OUT TSRMLS_CC);
 693         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_IN"), PGRES_COPY_IN TSRMLS_CC);
 694         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("BAD_RESPONSE"), PGRES_BAD_RESPONSE TSRMLS_CC);
 695         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("NONFATAL_ERROR"), PGRES_NONFATAL_ERROR TSRMLS_CC);
 696         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("FATAL_ERROR"), PGRES_FATAL_ERROR TSRMLS_CC);
 697         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("COPY_BOTH"), PGRES_COPY_BOTH TSRMLS_CC);
 698         zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("SINGLE_TUPLE"), PGRES_SINGLE_TUPLE TSRMLS_CC);
 699
 700         /*
 701         REGISTER_INI_ENTRIES();
 702         */
 703         return SUCCESS;
 704 }
 705 /* }}} */
 706
 707 /* {{{ PHP_MSHUTDOWN_FUNCTION
 708  */
 709 PHP_MSHUTDOWN_FUNCTION(pq)
 710 {
 711         /* uncomment this line if you have INI entries
 712         UNREGISTER_INI_ENTRIES();
 713         */
 714         return SUCCESS;
 715 }
 716 /* }}} */
 717
 718 /* {{{ PHP_MINFO_FUNCTION
 719  */
 720 PHP_MINFO_FUNCTION(pq)
 721 {
 722         php_info_print_table_start();
 723         php_info_print_table_header(2, "pq support", "enabled");
 724         php_info_print_table_end();
 725
 726         /* Remove comments if you have entries in php.ini
 727         DISPLAY_INI_ENTRIES();
 728         */
 729 }
 730 /* }}} */
 731
 732
 733
 734 /*
 735  * Local variables:
 736  * tab-width: 4
 737  * c-basic-offset: 4
 738  * End:
 739  * vim600: noet sw=4 ts=4 fdm=marker
 740  * vim<600: noet sw=4 ts=4
 741  */