2 +--------------------------------------------------------------------+
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 +--------------------------------------------------------------------+
19 #define SMART_STR_PREALLOC 256
20 #include <ext/standard/php_smart_str.h>
22 #include <libpq-events.h>
26 #include "php_pq_misc.h"
27 #include "php_pq_object.h"
28 #include "php_pqexc.h"
29 #include "php_pqconn.h"
30 #include "php_pqconn_event.h"
31 #include "php_pqres.h"
32 #include "php_pqstm.h"
33 #include "php_pqtxn.h"
34 #include "php_pqcur.h"
36 zend_class_entry
*php_pqconn_class_entry
;
37 static zend_object_handlers php_pqconn_object_handlers
;
38 static HashTable php_pqconn_object_prophandlers
;
41 static void php_pqconn_del_eventhandler(php_pqconn_object_t *obj, const char *type_str, size_t type_len, ulong id TSRMLS_DC)
45 if (SUCCESS == zend_hash_find(&obj->intern->eventhandlers, type_str, type_len + 1, (void *) &evhs)) {
46 zend_hash_index_del(Z_ARRVAL_PP(evhs), id);
51 static ulong
php_pqconn_add_eventhandler(php_pqconn_object_t
*obj
, const char *type_str
, size_t type_len
, php_pq_callback_t
*cb TSRMLS_DC
)
56 if (SUCCESS
!= zend_hash_find(&obj
->intern
->eventhandlers
, type_str
, type_len
+ 1, (void *) &evhs
)) {
59 zend_hash_init(&evh
, 1, NULL
, (dtor_func_t
) php_pq_callback_dtor
, 0);
60 zend_hash_add(&obj
->intern
->eventhandlers
, type_str
, type_len
+ 1, (void *) &evh
, sizeof(evh
), (void *) &evhs
);
63 php_pq_callback_addref(cb
);
64 h
= zend_hash_next_free_element(evhs
);
65 zend_hash_index_update(evhs
, h
, (void *) cb
, sizeof(*cb
), NULL
);
70 static void php_pqconn_object_free(void *o TSRMLS_DC
)
72 php_pqconn_object_t
*obj
= o
;
74 fprintf(stderr
, "FREE conn(#%d) %p\n", obj
->zv
.handle
, obj
);
77 php_pq_callback_dtor(&obj
->intern
->onevent
);
78 php_resource_factory_handle_dtor(&obj
->intern
->factory
, obj
->intern
->conn TSRMLS_CC
);
79 php_resource_factory_dtor(&obj
->intern
->factory
);
80 zend_hash_destroy(&obj
->intern
->listeners
);
81 zend_hash_destroy(&obj
->intern
->converters
);
82 zend_hash_destroy(&obj
->intern
->eventhandlers
);
86 zend_object_std_dtor((zend_object
*) o TSRMLS_CC
);
91 zend_object_value
php_pqconn_create_object_ex(zend_class_entry
*ce
, php_pqconn_t
*intern
, php_pqconn_object_t
**ptr TSRMLS_DC
)
93 php_pqconn_object_t
*o
;
95 o
= ecalloc(1, sizeof(*o
));
96 zend_object_std_init((zend_object
*) o
, ce TSRMLS_CC
);
97 object_properties_init((zend_object
*) o
, ce
);
98 o
->prophandler
= &php_pqconn_object_prophandlers
;
108 o
->zv
.handle
= zend_objects_store_put((zend_object
*) o
, NULL
, php_pqconn_object_free
, NULL TSRMLS_CC
);
109 o
->zv
.handlers
= &php_pqconn_object_handlers
;
114 static zend_object_value
php_pqconn_create_object(zend_class_entry
*class_type TSRMLS_DC
)
116 return php_pqconn_create_object_ex(class_type
, NULL
, NULL TSRMLS_CC
);
119 static void php_pqconn_object_read_status(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
121 php_pqconn_object_t
*obj
= o
;
123 RETVAL_LONG(PQstatus(obj
->intern
->conn
));
126 static void php_pqconn_object_read_transaction_status(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
128 php_pqconn_object_t
*obj
= o
;
130 RETVAL_LONG(PQtransactionStatus(obj
->intern
->conn
));
133 static void php_pqconn_object_read_error_message(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
135 php_pqconn_object_t
*obj
= o
;
136 char *error
= PHP_PQerrorMessage(obj
->intern
->conn
);
139 RETVAL_STRING(error
, 1);
145 static int apply_notify_listener(void *p
, void *arg TSRMLS_DC
)
147 php_pq_callback_t
*listener
= p
;
149 zval
*zpid
, *zchannel
, *zmessage
;
152 ZVAL_LONG(zpid
, nfy
->be_pid
);
153 MAKE_STD_ZVAL(zchannel
);
154 ZVAL_STRING(zchannel
, nfy
->relname
, 1);
155 MAKE_STD_ZVAL(zmessage
);
156 ZVAL_STRING(zmessage
, nfy
->extra
, 1);
158 zend_fcall_info_argn(&listener
->fci TSRMLS_CC
, 3, &zchannel
, &zmessage
, &zpid
);
159 zend_fcall_info_call(&listener
->fci
, &listener
->fcc
, NULL
, NULL TSRMLS_CC
);
161 zval_ptr_dtor(&zchannel
);
162 zval_ptr_dtor(&zmessage
);
163 zval_ptr_dtor(&zpid
);
165 return ZEND_HASH_APPLY_KEEP
;
168 static int apply_notify_listeners(void *p TSRMLS_DC
, int argc
, va_list argv
, zend_hash_key
*key
)
170 HashTable
*listeners
= p
;
171 PGnotify
*nfy
= va_arg(argv
, PGnotify
*);
173 if (0 == fnmatch(key
->arKey
, nfy
->relname
, 0)) {
174 zend_hash_apply_with_argument(listeners
, apply_notify_listener
, nfy TSRMLS_CC
);
177 return ZEND_HASH_APPLY_KEEP
;
180 void php_pqconn_notify_listeners(php_pqconn_object_t
*obj TSRMLS_DC
)
184 while ((nfy
= PQnotifies(obj
->intern
->conn
))) {
185 zend_hash_apply_with_arguments(&obj
->intern
->listeners TSRMLS_CC
, apply_notify_listeners
, 1, nfy
);
190 static void php_pqconn_object_read_busy(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
192 php_pqconn_object_t
*obj
= o
;
194 RETVAL_BOOL(PQisBusy(obj
->intern
->conn
));
197 static void php_pqconn_object_read_encoding(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
199 php_pqconn_object_t
*obj
= o
;
201 RETVAL_STRING(pg_encoding_to_char(PQclientEncoding(obj
->intern
->conn
)), 1);
204 static void php_pqconn_object_write_encoding(zval
*object
, void *o
, zval
*value TSRMLS_DC
)
206 php_pqconn_object_t
*obj
= o
;
209 if (Z_TYPE_P(value
) != IS_STRING
) {
210 if (Z_REFCOUNT_P(value
) > 1) {
213 ZVAL_ZVAL(tmp
, zenc
, 1, 0);
214 convert_to_string(tmp
);
217 convert_to_string_ex(&zenc
);
221 if (0 > PQsetClientEncoding(obj
->intern
->conn
, Z_STRVAL_P(zenc
))) {
222 zend_error(E_NOTICE
, "Unrecognized encoding '%s'", Z_STRVAL_P(zenc
));
226 zval_ptr_dtor(&zenc
);
230 static void php_pqconn_object_read_unbuffered(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
232 php_pqconn_object_t
*obj
= o
;
234 RETVAL_BOOL(obj
->intern
->unbuffered
);
237 static void php_pqconn_object_write_unbuffered(zval
*object
, void *o
, zval
*value TSRMLS_DC
)
239 php_pqconn_object_t
*obj
= o
;
241 obj
->intern
->unbuffered
= zend_is_true(value
);
244 static void php_pqconn_object_read_db(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
246 php_pqconn_object_t
*obj
= o
;
247 char *db
= PQdb(obj
->intern
->conn
);
250 RETVAL_STRING(db
, 1);
252 RETVAL_EMPTY_STRING();
256 static void php_pqconn_object_read_user(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
258 php_pqconn_object_t
*obj
= o
;
259 char *user
= PQuser(obj
->intern
->conn
);
262 RETVAL_STRING(user
, 1);
264 RETVAL_EMPTY_STRING();
268 static void php_pqconn_object_read_pass(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
270 php_pqconn_object_t
*obj
= o
;
271 char *pass
= PQpass(obj
->intern
->conn
);
274 RETVAL_STRING(pass
, 1);
276 RETVAL_EMPTY_STRING();
280 static void php_pqconn_object_read_host(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
282 php_pqconn_object_t
*obj
= o
;
283 char *host
= PQhost(obj
->intern
->conn
);
286 RETVAL_STRING(host
, 1);
288 RETVAL_EMPTY_STRING();
292 static void php_pqconn_object_read_port(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
294 php_pqconn_object_t
*obj
= o
;
295 char *port
= PQport(obj
->intern
->conn
);
298 RETVAL_STRING(port
, 1);
300 RETVAL_EMPTY_STRING();
304 static void php_pqconn_object_read_options(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
306 php_pqconn_object_t
*obj
= o
;
307 char *options
= PQoptions(obj
->intern
->conn
);
310 RETVAL_STRING(options
, 1);
312 RETVAL_EMPTY_STRING();
316 static int apply_read_event_handler_ex(void *p
, void *arg TSRMLS_DC
)
319 zval
*zcb
= php_pq_callback_to_zval(p
);
321 zend_hash_next_index_insert(rv
, &zcb
, sizeof(zval
*), NULL
);
323 return ZEND_HASH_APPLY_KEEP
;
326 static int apply_read_event_handlers(void *p TSRMLS_DC
, int argc
, va_list argv
, zend_hash_key
*key
)
328 HashTable
*evhs
= p
, *rv
= va_arg(argv
, HashTable
*);
329 zval
*entry
, **entry_ptr
;
331 MAKE_STD_ZVAL(entry
);
332 array_init_size(entry
, zend_hash_num_elements(evhs
));
334 if (key
->nKeyLength
) {
335 zend_hash_add(rv
, key
->arKey
, key
->nKeyLength
, &entry
, sizeof(zval
*), (void *) &entry_ptr
);
337 zend_hash_index_update(rv
, key
->h
, &entry
, sizeof(zval
*), (void *) &entry_ptr
);
340 zend_hash_apply_with_argument(evhs
, apply_read_event_handler_ex
, Z_ARRVAL_PP(entry_ptr
) TSRMLS_CC
);
342 return ZEND_HASH_APPLY_KEEP
;
344 static void php_pqconn_object_read_event_handlers(zval
*object
, void *o
, zval
*return_value TSRMLS_DC
)
346 php_pqconn_object_t
*obj
= o
;
348 array_init(return_value
);
349 zend_hash_apply_with_arguments(&obj
->intern
->eventhandlers TSRMLS_CC
, apply_read_event_handlers
, 1, Z_ARRVAL_P(return_value
) TSRMLS_CC
);
352 static STATUS
php_pqconn_update_socket(zval
*this_ptr
, php_pqconn_object_t
*obj TSRMLS_DC
)
354 zval
*zsocket
, zmember
;
360 obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
363 INIT_PZVAL(&zmember
);
364 ZVAL_STRINGL(&zmember
, "socket", sizeof("socket")-1, 0);
365 MAKE_STD_ZVAL(zsocket
);
367 if ((CONNECTION_BAD
!= PQstatus(obj
->intern
->conn
))
368 && (-1 < (socket
= PQsocket(obj
->intern
->conn
)))
369 && (stream
= php_stream_fopen_from_fd(socket
, "r+b", NULL
))) {
370 stream
->flags
|= PHP_STREAM_FLAG_NO_CLOSE
;
371 php_stream_to_zval(stream
, zsocket
);
377 zend_get_std_object_handlers()->write_property(getThis(), &zmember
, zsocket
, NULL TSRMLS_CC
);
378 zval_ptr_dtor(&zsocket
);
383 static void *php_pqconn_resource_factory_ctor(void *data
, void *init_arg TSRMLS_DC
)
385 php_pqconn_resource_factory_data_t
*o
= init_arg
;
386 PGconn
*conn
= NULL
;;
388 if (o
->flags
& PHP_PQCONN_ASYNC
) {
389 conn
= PQconnectStart(o
->dsn
);
391 conn
= PQconnectdb(o
->dsn
);
395 PQregisterEventProc(conn
, php_pqconn_event
, "ext-pq", NULL
);
401 static void php_pqconn_resource_factory_dtor(void *opaque
, void *handle TSRMLS_DC
)
403 php_pqconn_event_data_t
*evdata
= PQinstanceData(handle
, php_pqconn_event
);
405 /* we don't care for anything, except free'ing evdata */
407 PQsetInstanceData(handle
, php_pqconn_event
, NULL
);
408 memset(evdata
, 0, sizeof(*evdata
));
415 static php_resource_factory_ops_t php_pqconn_resource_factory_ops
= {
416 php_pqconn_resource_factory_ctor
,
418 php_pqconn_resource_factory_dtor
421 php_resource_factory_ops_t
*php_pqconn_get_resource_factory_ops(void)
423 return &php_pqconn_resource_factory_ops
;
426 static void php_pqconn_wakeup(php_persistent_handle_factory_t
*f
, void **handle TSRMLS_DC
)
428 // FIXME: ping server
431 static int apply_unlisten(void *p TSRMLS_DC
, int argc
, va_list argv
, zend_hash_key
*key
)
433 php_pqconn_object_t
*obj
= va_arg(argv
, php_pqconn_object_t
*);
434 char *quoted_channel
= PQescapeIdentifier(obj
->intern
->conn
, key
->arKey
, key
->nKeyLength
- 1);
436 if (quoted_channel
) {
440 spprintf(&cmd
, 0, "UNLISTEN %s", quoted_channel
);
441 if ((res
= PQexec(obj
->intern
->conn
, cmd
))) {
446 PQfreemem(quoted_channel
);
449 return ZEND_HASH_APPLY_REMOVE
;
452 static void php_pqconn_retire(php_persistent_handle_factory_t
*f
, void **handle TSRMLS_DC
)
454 php_pqconn_event_data_t
*evdata
= PQinstanceData(*handle
, php_pqconn_event
);
459 PQsetInstanceData(*handle
, php_pqconn_event
, NULL
);
462 PQsetNoticeReceiver(*handle
, php_pqconn_notice_ignore
, NULL
);
464 /* cancel async queries */
465 if (PQisBusy(*handle
) && (cancel
= PQgetCancel(*handle
))) {
468 PQcancel(cancel
, err
, sizeof(err
));
469 PQfreeCancel(cancel
);
471 /* clean up async results */
472 while ((res
= PQgetResult(*handle
))) {
476 /* clean up transaction & session */
477 switch (PQtransactionStatus(*handle
)) {
479 res
= PQexec(*handle
, "RESET ALL");
482 res
= PQexec(*handle
, "ROLLBACK; RESET ALL");
491 /* clean up notify listeners */
492 zend_hash_apply_with_arguments(&evdata
->obj
->intern
->listeners TSRMLS_CC
, apply_unlisten
, 1, evdata
->obj
);
494 /* release instance data */
495 //memset(evdata, 0, sizeof(*evdata));
500 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_construct
, 0, 0, 1)
501 ZEND_ARG_INFO(0, dsn
)
502 ZEND_ARG_INFO(0, async
)
504 static PHP_METHOD(pqconn
, __construct
) {
505 zend_error_handling zeh
;
511 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
512 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|sl", &dsn_str
, &dsn_len
, &flags
);
513 zend_restore_error_handling(&zeh TSRMLS_CC
);
516 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
519 throw_exce(EX_BAD_METHODCALL TSRMLS_CC
, "pq\\Connection already initialized");
521 php_pqconn_event_data_t
*evdata
= php_pqconn_event_data_init(obj TSRMLS_CC
);
522 php_pqconn_resource_factory_data_t rfdata
= {dsn_str
, flags
};
524 obj
->intern
= ecalloc(1, sizeof(*obj
->intern
));
526 zend_hash_init(&obj
->intern
->listeners
, 0, NULL
, (dtor_func_t
) zend_hash_destroy
, 0);
527 zend_hash_init(&obj
->intern
->converters
, 0, NULL
, ZVAL_PTR_DTOR
, 0);
528 zend_hash_init(&obj
->intern
->eventhandlers
, 0, NULL
, (dtor_func_t
) zend_hash_destroy
, 0);
530 if (flags
& PHP_PQCONN_PERSISTENT
) {
531 php_persistent_handle_factory_t
*phf
= php_persistent_handle_concede(NULL
, ZEND_STRL("pq\\Connection"), dsn_str
, dsn_len
, php_pqconn_wakeup
, php_pqconn_retire TSRMLS_CC
);
532 php_resource_factory_init(&obj
->intern
->factory
, php_persistent_handle_get_resource_factory_ops(), phf
, (void (*)(void*)) php_persistent_handle_abandon
);
534 php_resource_factory_init(&obj
->intern
->factory
, &php_pqconn_resource_factory_ops
, NULL
, NULL
);
537 if (flags
& PHP_PQCONN_ASYNC
) {
538 obj
->intern
->poller
= (int (*)(PGconn
*)) PQconnectPoll
;
541 obj
->intern
->conn
= php_resource_factory_handle_ctor(&obj
->intern
->factory
, &rfdata TSRMLS_CC
);
543 PQsetInstanceData(obj
->intern
->conn
, php_pqconn_event
, evdata
);
544 PQsetNoticeReceiver(obj
->intern
->conn
, php_pqconn_notice_recv
, evdata
);
546 if (SUCCESS
!= php_pqconn_update_socket(getThis(), obj TSRMLS_CC
)) {
547 throw_exce(EX_CONNECTION_FAILED TSRMLS_CC
, "Connection failed (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
553 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_reset
, 0, 0, 0)
555 static PHP_METHOD(pqconn
, reset
) {
556 zend_error_handling zeh
;
559 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
560 rv
= zend_parse_parameters_none();
561 zend_restore_error_handling(&zeh TSRMLS_CC
);
564 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
567 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
569 PQreset(obj
->intern
->conn
);
571 if (CONNECTION_OK
!= PQstatus(obj
->intern
->conn
)) {
572 throw_exce(EX_CONNECTION_FAILED TSRMLS_CC
, "Connection reset failed: (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
575 php_pqconn_notify_listeners(obj TSRMLS_CC
);
580 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_reset_async
, 0, 0, 0)
582 static PHP_METHOD(pqconn
, resetAsync
) {
583 zend_error_handling zeh
;
586 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
587 rv
= zend_parse_parameters_none();
588 zend_restore_error_handling(&zeh TSRMLS_CC
);
591 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
594 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
596 if (!PQresetStart(obj
->intern
->conn
)) {
597 throw_exce(EX_IO TSRMLS_CC
, "Failed to start connection reset (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
599 obj
->intern
->poller
= (int (*)(PGconn
*)) PQresetPoll
;
602 php_pqconn_notify_listeners(obj TSRMLS_CC
);
607 static void php_pqconn_add_listener(php_pqconn_object_t
*obj
, const char *channel_str
, size_t channel_len
, php_pq_callback_t
*listener TSRMLS_DC
)
609 HashTable ht
, *existing_listeners
;
611 php_pq_callback_addref(listener
);
613 if (SUCCESS
== zend_hash_find(&obj
->intern
->listeners
, channel_str
, channel_len
+ 1, (void *) &existing_listeners
)) {
614 zend_hash_next_index_insert(existing_listeners
, (void *) listener
, sizeof(*listener
), NULL
);
616 zend_hash_init(&ht
, 1, NULL
, (dtor_func_t
) php_pq_callback_dtor
, 0);
617 zend_hash_next_index_insert(&ht
, (void *) listener
, sizeof(*listener
), NULL
);
618 zend_hash_add(&obj
->intern
->listeners
, channel_str
, channel_len
+ 1, (void *) &ht
, sizeof(HashTable
), NULL
);
622 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_listen
, 0, 0, 0)
623 ZEND_ARG_INFO(0, channel
)
624 ZEND_ARG_INFO(0, callable
)
626 static PHP_METHOD(pqconn
, listen
) {
627 zend_error_handling zeh
;
628 char *channel_str
= NULL
;
630 php_pq_callback_t listener
= {{0}};
633 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
634 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sf", &channel_str
, &channel_len
, &listener
.fci
, &listener
.fcc
);
635 zend_restore_error_handling(&zeh TSRMLS_CC
);
638 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
641 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
643 char *quoted_channel
= PQescapeIdentifier(obj
->intern
->conn
, channel_str
, channel_len
);
645 if (!quoted_channel
) {
646 throw_exce(EX_ESCAPE TSRMLS_CC
, "Failed to escape channel identifier (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
651 smart_str_appends(&cmd
, "LISTEN ");
652 smart_str_appends(&cmd
, quoted_channel
);
655 res
= PQexec(obj
->intern
->conn
, cmd
.c
);
657 smart_str_free(&cmd
);
658 PQfreemem(quoted_channel
);
661 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to install listener (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
663 if (SUCCESS
== php_pqres_success(res TSRMLS_CC
)) {
664 obj
->intern
->poller
= PQconsumeInput
;
665 php_pqconn_add_listener(obj
, channel_str
, channel_len
, &listener TSRMLS_CC
);
670 php_pqconn_notify_listeners(obj TSRMLS_CC
);
676 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_listen_async
, 0, 0, 0)
677 ZEND_ARG_INFO(0, channel
)
678 ZEND_ARG_INFO(0, callable
)
680 static PHP_METHOD(pqconn
, listenAsync
) {
681 zend_error_handling zeh
;
682 char *channel_str
= NULL
;
684 php_pq_callback_t listener
= {{0}};
687 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
688 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sf", &channel_str
, &channel_len
, &listener
.fci
, &listener
.fcc
);
689 zend_restore_error_handling(&zeh TSRMLS_CC
);
692 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
695 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
697 char *quoted_channel
= PQescapeIdentifier(obj
->intern
->conn
, channel_str
, channel_len
);
699 if (!quoted_channel
) {
700 throw_exce(EX_ESCAPE TSRMLS_CC
, "Failed to escape channel identifier (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
704 smart_str_appends(&cmd
, "LISTEN ");
705 smart_str_appends(&cmd
, quoted_channel
);
708 if (!PQsendQuery(obj
->intern
->conn
, cmd
.c
)) {
709 throw_exce(EX_IO TSRMLS_CC
, "Failed to install listener (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
711 obj
->intern
->poller
= PQconsumeInput
;
712 php_pqconn_add_listener(obj
, channel_str
, channel_len
, &listener TSRMLS_CC
);
715 smart_str_free(&cmd
);
716 PQfreemem(quoted_channel
);
717 php_pqconn_notify_listeners(obj TSRMLS_CC
);
723 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_notify
, 0, 0, 2)
724 ZEND_ARG_INFO(0, channel
)
725 ZEND_ARG_INFO(0, message
)
727 static PHP_METHOD(pqconn
, notify
) {
728 zend_error_handling zeh
;
729 char *channel_str
, *message_str
;
730 int channel_len
, message_len
;
733 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
734 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "ss", &channel_str
, &channel_len
, &message_str
, &message_len
);
735 zend_restore_error_handling(&zeh TSRMLS_CC
);
738 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
741 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
744 char *params
[2] = {channel_str
, message_str
};
746 res
= PQexecParams(obj
->intern
->conn
, "select pg_notify($1, $2)", 2, NULL
, (const char *const*) params
, NULL
, NULL
, 0);
749 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to notify listeners (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
751 php_pqres_success(res TSRMLS_CC
);
755 php_pqconn_notify_listeners(obj TSRMLS_CC
);
760 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_notify_async
, 0, 0, 2)
761 ZEND_ARG_INFO(0, channel
)
762 ZEND_ARG_INFO(0, message
)
764 static PHP_METHOD(pqconn
, notifyAsync
) {
765 zend_error_handling zeh
;
766 char *channel_str
, *message_str
;
767 int channel_len
, message_len
;
770 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
771 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "ss", &channel_str
, &channel_len
, &message_str
, &message_len
);
772 zend_restore_error_handling(&zeh TSRMLS_CC
);
775 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
778 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
780 char *params
[2] = {channel_str
, message_str
};
782 if (!PQsendQueryParams(obj
->intern
->conn
, "select pg_notify($1, $2)", 2, NULL
, (const char *const*) params
, NULL
, NULL
, 0)) {
783 throw_exce(EX_IO TSRMLS_CC
, "Failed to notify listeners (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
785 obj
->intern
->poller
= PQconsumeInput
;
788 php_pqconn_notify_listeners(obj TSRMLS_CC
);
793 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_poll
, 0, 0, 0)
795 static PHP_METHOD(pqconn
, poll
) {
796 zend_error_handling zeh
;
799 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
800 rv
= zend_parse_parameters_none();
801 zend_restore_error_handling(&zeh TSRMLS_CC
);
804 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
807 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
808 } else if (!obj
->intern
->poller
) {
809 throw_exce(EX_RUNTIME TSRMLS_CC
, "No asynchronous operation active");
811 if (obj
->intern
->poller
== PQconsumeInput
) {
812 RETVAL_LONG(obj
->intern
->poller(obj
->intern
->conn
) * PGRES_POLLING_OK
);
814 RETVAL_LONG(obj
->intern
->poller(obj
->intern
->conn
));
816 php_pqconn_notify_listeners(obj TSRMLS_CC
);
821 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_exec
, 0, 0, 1)
822 ZEND_ARG_INFO(0, query
)
824 static PHP_METHOD(pqconn
, exec
) {
825 zend_error_handling zeh
;
830 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
831 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &query_str
, &query_len
);
832 zend_restore_error_handling(&zeh TSRMLS_CC
);
835 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
838 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
840 PGresult
*res
= PQexec(obj
->intern
->conn
, query_str
);
843 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to execute query (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
844 } else if (SUCCESS
== php_pqres_success(res TSRMLS_CC
)) {
845 php_pq_object_to_zval_no_addref(PQresultInstanceData(res
, php_pqconn_event
), &return_value TSRMLS_CC
);
850 php_pqconn_notify_listeners(obj TSRMLS_CC
);
855 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_get_result
, 0, 0, 0)
857 static PHP_METHOD(pqconn
, getResult
) {
858 zend_error_handling zeh
;
861 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
862 rv
= zend_parse_parameters_none();
863 zend_restore_error_handling(&zeh TSRMLS_CC
);
866 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
869 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
871 PGresult
*res
= PQgetResult(obj
->intern
->conn
);
876 php_pq_object_to_zval_no_addref(PQresultInstanceData(res
, php_pqconn_event
), &return_value TSRMLS_CC
);
879 php_pqconn_notify_listeners(obj TSRMLS_CC
);
884 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_exec_async
, 0, 0, 1)
885 ZEND_ARG_INFO(0, query
)
886 ZEND_ARG_INFO(0, callable
)
888 static PHP_METHOD(pqconn
, execAsync
) {
889 zend_error_handling zeh
;
890 php_pq_callback_t resolver
= {{0}};
895 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
896 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|f", &query_str
, &query_len
, &resolver
.fci
, &resolver
.fcc
);
897 zend_restore_error_handling(&zeh TSRMLS_CC
);
900 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
903 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
904 } else if (!PQsendQuery(obj
->intern
->conn
, query_str
)) {
905 throw_exce(EX_IO TSRMLS_CC
, "Failed to execute query (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
906 } else if (obj
->intern
->unbuffered
&& !PQsetSingleRowMode(obj
->intern
->conn
)) {
907 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to enable unbuffered mode (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
909 obj
->intern
->poller
= PQconsumeInput
;
910 php_pq_callback_dtor(&obj
->intern
->onevent
);
911 if (resolver
.fci
.size
> 0) {
912 obj
->intern
->onevent
= resolver
;
913 php_pq_callback_addref(&obj
->intern
->onevent
);
915 php_pqconn_notify_listeners(obj TSRMLS_CC
);
920 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_exec_params
, 0, 0, 2)
921 ZEND_ARG_INFO(0, query
)
922 ZEND_ARG_ARRAY_INFO(0, params
, 0)
923 ZEND_ARG_ARRAY_INFO(0, types
, 1)
925 static PHP_METHOD(pqconn
, execParams
) {
926 zend_error_handling zeh
;
933 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
934 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sa/|a/!", &query_str
, &query_len
, &zparams
, &ztypes
);
935 zend_restore_error_handling(&zeh TSRMLS_CC
);
938 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
941 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
944 php_pq_params_t
*params
;
946 params
= php_pq_params_init(&obj
->intern
->converters
, ztypes
? Z_ARRVAL_P(ztypes
) : NULL
, Z_ARRVAL_P(zparams
) TSRMLS_CC
);
947 res
= PQexecParams(obj
->intern
->conn
, query_str
, params
->param
.count
, params
->type
.oids
, (const char *const*) params
->param
.strings
, NULL
, NULL
, 0);
948 php_pq_params_free(¶ms
);
951 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to execute query (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
953 if (SUCCESS
== php_pqres_success(res TSRMLS_CC
)) {
954 php_pq_object_to_zval_no_addref(PQresultInstanceData(res
, php_pqconn_event
), &return_value TSRMLS_CC
);
959 php_pqconn_notify_listeners(obj TSRMLS_CC
);
965 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_exec_params_async
, 0, 0, 2)
966 ZEND_ARG_INFO(0, query
)
967 ZEND_ARG_ARRAY_INFO(0, params
, 0)
968 ZEND_ARG_ARRAY_INFO(0, types
, 1)
969 ZEND_ARG_INFO(0, callable
)
971 static PHP_METHOD(pqconn
, execParamsAsync
) {
972 zend_error_handling zeh
;
973 php_pq_callback_t resolver
= {{0}};
980 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
981 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sa/|a/!f", &query_str
, &query_len
, &zparams
, &ztypes
, &resolver
.fci
, &resolver
.fcc
);
982 zend_restore_error_handling(&zeh TSRMLS_CC
);
985 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
988 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
991 php_pq_params_t
*params
;
993 params
= php_pq_params_init(&obj
->intern
->converters
, ztypes
? Z_ARRVAL_P(ztypes
) : NULL
, Z_ARRVAL_P(zparams
) TSRMLS_CC
);
994 rc
= PQsendQueryParams(obj
->intern
->conn
, query_str
, params
->param
.count
, params
->type
.oids
, (const char *const*) params
->param
.strings
, NULL
, NULL
, 0);
995 php_pq_params_free(¶ms
);
998 throw_exce(EX_IO TSRMLS_CC
, "Failed to execute query (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
999 } else if (obj
->intern
->unbuffered
&& !PQsetSingleRowMode(obj
->intern
->conn
)) {
1000 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to enable unbuffered mode (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1002 obj
->intern
->poller
= PQconsumeInput
;
1003 php_pq_callback_dtor(&obj
->intern
->onevent
);
1004 if (resolver
.fci
.size
> 0) {
1005 obj
->intern
->onevent
= resolver
;
1006 php_pq_callback_addref(&obj
->intern
->onevent
);
1008 php_pqconn_notify_listeners(obj TSRMLS_CC
);
1012 zend_restore_error_handling(&zeh TSRMLS_CC
);
1015 STATUS
php_pqconn_prepare(zval
*object
, php_pqconn_object_t
*obj
, const char *name
, const char *query
, php_pq_params_t
*params TSRMLS_DC
)
1021 obj
= zend_object_store_get_object(object TSRMLS_CC
);
1024 res
= PQprepare(obj
->intern
->conn
, name
, query
, params
->type
.count
, params
->type
.oids
);
1028 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to prepare statement (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1030 rv
= php_pqres_success(res TSRMLS_CC
);
1032 php_pqconn_notify_listeners(obj TSRMLS_CC
);
1038 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_prepare
, 0, 0, 2)
1039 ZEND_ARG_INFO(0, name
)
1040 ZEND_ARG_INFO(0, query
)
1041 ZEND_ARG_ARRAY_INFO(0, types
, 1)
1042 ZEND_END_ARG_INFO();
1043 static PHP_METHOD(pqconn
, prepare
) {
1044 zend_error_handling zeh
;
1045 zval
*ztypes
= NULL
;
1046 char *name_str
, *query_str
;
1047 int name_len
, *query_len
;
1050 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1051 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "ss|a/!", &name_str
, &name_len
, &query_str
, &query_len
, &ztypes
);
1052 zend_restore_error_handling(&zeh TSRMLS_CC
);
1054 if (SUCCESS
== rv
) {
1055 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1058 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1060 php_pq_params_t
*params
= php_pq_params_init(&obj
->intern
->converters
, ztypes
? Z_ARRVAL_P(ztypes
) : NULL
, NULL TSRMLS_CC
);
1062 if (SUCCESS
!= php_pqconn_prepare(getThis(), obj
, name_str
, query_str
, params TSRMLS_CC
)) {
1063 php_pq_params_free(¶ms
);
1065 php_pqstm_t
*stm
= ecalloc(1, sizeof(*stm
));
1067 php_pq_object_addref(obj TSRMLS_CC
);
1069 stm
->name
= estrdup(name_str
);
1070 stm
->params
= params
;
1071 ZEND_INIT_SYMTABLE(&stm
->bound
);
1073 return_value
->type
= IS_OBJECT
;
1074 return_value
->value
.obj
= php_pqstm_create_object_ex(php_pqstm_class_entry
, stm
, NULL TSRMLS_CC
);
1080 STATUS
php_pqconn_prepare_async(zval
*object
, php_pqconn_object_t
*obj
, const char *name
, const char *query
, php_pq_params_t
*params TSRMLS_DC
)
1085 obj
= zend_object_store_get_object(object TSRMLS_CC
);
1088 if (!PQsendPrepare(obj
->intern
->conn
, name
, query
, params
->type
.count
, params
->type
.oids
)) {
1090 throw_exce(EX_IO TSRMLS_CC
, "Failed to prepare statement (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1091 } else if (obj
->intern
->unbuffered
&& !PQsetSingleRowMode(obj
->intern
->conn
)) {
1093 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to enable unbuffered mode (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1096 obj
->intern
->poller
= PQconsumeInput
;
1097 php_pqconn_notify_listeners(obj TSRMLS_CC
);
1103 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_prepare_async
, 0, 0, 2)
1104 ZEND_ARG_INFO(0, name
)
1105 ZEND_ARG_INFO(0, query
)
1106 ZEND_ARG_ARRAY_INFO(0, types
, 1)
1107 ZEND_END_ARG_INFO();
1108 static PHP_METHOD(pqconn
, prepareAsync
) {
1109 zend_error_handling zeh
;
1110 zval
*ztypes
= NULL
;
1111 char *name_str
, *query_str
;
1112 int name_len
, *query_len
;
1115 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1116 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "ss|a/!", &name_str
, &name_len
, &query_str
, &query_len
, &ztypes
);
1117 zend_restore_error_handling(&zeh TSRMLS_CC
);
1119 if (SUCCESS
== rv
) {
1120 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1123 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1125 php_pq_params_t
*params
= php_pq_params_init(&obj
->intern
->converters
, ztypes
? Z_ARRVAL_P(ztypes
) : NULL
, NULL TSRMLS_CC
);
1127 if (SUCCESS
!= php_pqconn_prepare_async(getThis(), obj
, name_str
, query_str
, params TSRMLS_CC
)) {
1128 php_pq_params_free(¶ms
);
1130 php_pqstm_t
*stm
= ecalloc(1, sizeof(*stm
));
1132 php_pq_object_addref(obj TSRMLS_CC
);
1134 stm
->name
= estrdup(name_str
);
1135 stm
->params
= params
;
1136 ZEND_INIT_SYMTABLE(&stm
->bound
);
1138 return_value
->type
= IS_OBJECT
;
1139 return_value
->value
.obj
= php_pqstm_create_object_ex(php_pqstm_class_entry
, stm
, NULL TSRMLS_CC
);
1145 static inline char *declare_str(const char *name_str
, size_t name_len
, unsigned flags
, const char *query_str
, size_t query_len
)
1147 size_t decl_len
= name_len
+ query_len
+ sizeof("DECLARE BINARY INSENSITIVE NO SCROLL CURSOR WITHOUT HOLD FOR ");
1150 decl_str
= emalloc(decl_len
);
1151 decl_len
= slprintf(decl_str
, decl_len
, "DECLARE %s %s %s %s CURSOR %s FOR %s",
1153 (flags
& PHP_PQ_DECLARE_BINARY
) ? "BINARY" : "",
1154 (flags
& PHP_PQ_DECLARE_INSENSITIVE
) ? "INSENSITIVE" : "",
1155 (flags
& PHP_PQ_DECLARE_NO_SCROLL
) ? "NO SCROLL" :
1156 (flags
& PHP_PQ_DECLARE_SCROLL
) ? "SCROLL" : "",
1157 (flags
& PHP_PQ_DECLARE_WITH_HOLD
) ? "WITH HOLD" : "",
1163 STATUS
php_pqconn_declare(zval
*object
, php_pqconn_object_t
*obj
, const char *decl TSRMLS_DC
)
1169 obj
= zend_object_store_get_object(object TSRMLS_CC
);
1172 res
= PQexec(obj
->intern
->conn
, decl
);
1176 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to declare cursor (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1178 rv
= php_pqres_success(res TSRMLS_CC
);
1180 php_pqconn_notify_listeners(obj TSRMLS_CC
);
1186 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_declare
, 0, 0, 3)
1187 ZEND_ARG_INFO(0, name
)
1188 ZEND_ARG_INFO(0, flags
)
1189 ZEND_ARG_INFO(0, query
)
1190 ZEND_END_ARG_INFO();
1191 static PHP_METHOD(pqconn
, declare
) {
1192 zend_error_handling zeh
;
1193 char *name_str
, *query_str
;
1194 int name_len
, query_len
;
1198 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1199 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sls", &name_str
, &name_len
, &flags
, &query_str
, &query_len
);
1200 zend_restore_error_handling(&zeh TSRMLS_CC
);
1202 if (SUCCESS
== rv
) {
1203 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1206 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1208 char *decl
= declare_str(name_str
, name_len
, flags
, query_str
, query_len
);
1210 if (SUCCESS
!= php_pqconn_declare(getThis(), obj
, decl TSRMLS_CC
)) {
1213 php_pqcur_t
*cur
= ecalloc(1, sizeof(*cur
));
1215 php_pq_object_addref(obj TSRMLS_CC
);
1218 cur
->name
= estrdup(name_str
);
1221 return_value
->type
= IS_OBJECT
;
1222 return_value
->value
.obj
= php_pqcur_create_object_ex(php_pqcur_class_entry
, cur
, NULL TSRMLS_CC
);
1228 STATUS
php_pqconn_declare_async(zval
*object
, php_pqconn_object_t
*obj
, const char *decl TSRMLS_DC
)
1233 obj
= zend_object_store_get_object(object TSRMLS_CC
);
1236 if (!PQsendQuery(obj
->intern
->conn
, decl
)) {
1238 throw_exce(EX_IO TSRMLS_CC
, "Failed to declare cursor (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1239 } else if (obj
->intern
->unbuffered
&& !PQsetSingleRowMode(obj
->intern
->conn
)) {
1241 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to enable unbuffered mode (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1244 obj
->intern
->poller
= PQconsumeInput
;
1245 php_pqconn_notify_listeners(obj TSRMLS_CC
);
1251 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_declare_async
, 0, 0, 2)
1252 ZEND_ARG_INFO(0, name
)
1253 ZEND_ARG_INFO(0, flags
)
1254 ZEND_ARG_INFO(0, query
)
1255 ZEND_END_ARG_INFO();
1256 static PHP_METHOD(pqconn
, declareAsync
) {
1257 zend_error_handling zeh
;
1258 char *name_str
, *query_str
;
1259 int name_len
, query_len
;
1263 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1264 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sls", &name_str
, &name_len
, &flags
, &query_str
, &query_len
);
1265 zend_restore_error_handling(&zeh TSRMLS_CC
);
1267 if (SUCCESS
== rv
) {
1268 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1271 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1273 char *decl
= declare_str(name_str
, name_len
, flags
, query_str
, query_len
);
1275 if (SUCCESS
!= php_pqconn_declare_async(getThis(), obj
, decl TSRMLS_CC
)) {
1278 php_pqcur_t
*cur
= ecalloc(1, sizeof(*cur
));
1280 php_pq_object_addref(obj TSRMLS_CC
);
1283 cur
->name
= estrdup(name_str
);
1286 return_value
->type
= IS_OBJECT
;
1287 return_value
->value
.obj
= php_pqcur_create_object_ex(php_pqcur_class_entry
, cur
, NULL TSRMLS_CC
);
1293 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_quote
, 0, 0, 1)
1294 ZEND_ARG_INFO(0, string
)
1295 ZEND_END_ARG_INFO();
1296 static PHP_METHOD(pqconn
, quote
) {
1300 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &str
, &len
)) {
1301 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1304 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1306 char *quoted
= PQescapeLiteral(obj
->intern
->conn
, str
, len
);
1309 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to quote string (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1312 RETVAL_STRING(quoted
, 1);
1319 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_quote_name
, 0, 0, 1)
1320 ZEND_ARG_INFO(0, type
)
1321 ZEND_END_ARG_INFO();
1322 static PHP_METHOD(pqconn
, quoteName
) {
1326 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &str
, &len
)) {
1327 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1330 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1332 char *quoted
= PQescapeIdentifier(obj
->intern
->conn
, str
, len
);
1335 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to quote name (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1338 RETVAL_STRING(quoted
, 1);
1345 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_escape_bytea
, 0, 0, 1)
1346 ZEND_ARG_INFO(0, bytea
)
1347 ZEND_END_ARG_INFO();
1348 static PHP_METHOD(pqconn
, escapeBytea
) {
1352 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &str
, &len
)) {
1353 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1356 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1359 char *escaped_str
= (char *) PQescapeByteaConn(obj
->intern
->conn
, (unsigned char *) str
, len
, &escaped_len
);
1362 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to escape bytea (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1365 RETVAL_STRINGL(escaped_str
, escaped_len
- 1, 1);
1366 PQfreemem(escaped_str
);
1372 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_unescape_bytea
, 0, 0, 1)
1373 ZEND_ARG_INFO(0, bytea
)
1374 ZEND_END_ARG_INFO();
1375 static PHP_METHOD(pqconn
, unescapeBytea
) {
1379 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &str
, &len
)) {
1380 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1383 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1385 size_t unescaped_len
;
1386 char *unescaped_str
= (char *) PQunescapeBytea((unsigned char *)str
, &unescaped_len
);
1388 if (!unescaped_str
) {
1389 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to unescape bytea (%s)", PHP_PQerrorMessage(obj
->intern
->conn
));
1392 RETVAL_STRINGL(unescaped_str
, unescaped_len
, 1);
1393 PQfreemem(unescaped_str
);
1399 STATUS
php_pqconn_start_transaction(zval
*zconn
, php_pqconn_object_t
*conn_obj
, long isolation
, zend_bool readonly
, zend_bool deferrable TSRMLS_DC
)
1401 STATUS rv
= FAILURE
;
1404 conn_obj
= zend_object_store_get_object(zconn TSRMLS_CC
);
1407 if (!conn_obj
->intern
) {
1408 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1411 smart_str cmd
= {0};
1412 const char *il
= isolation_level(&isolation
);
1414 smart_str_appends(&cmd
, "START TRANSACTION ISOLATION LEVEL ");
1415 smart_str_appends(&cmd
, il
);
1416 smart_str_appends(&cmd
, ", READ ");
1417 smart_str_appends(&cmd
, readonly
? "ONLY" : "WRITE");
1418 smart_str_appends(&cmd
, ",");
1419 smart_str_appends(&cmd
, deferrable
? "" : " NOT");
1420 smart_str_appends(&cmd
, " DEFERRABLE");
1423 res
= PQexec(conn_obj
->intern
->conn
, cmd
.c
);
1426 throw_exce(EX_RUNTIME TSRMLS_CC
, "Failed to start transaction (%s)", PHP_PQerrorMessage(conn_obj
->intern
->conn
));
1428 rv
= php_pqres_success(res TSRMLS_CC
);
1430 php_pqconn_notify_listeners(conn_obj TSRMLS_CC
);
1433 smart_str_free(&cmd
);
1439 STATUS
php_pqconn_start_transaction_async(zval
*zconn
, php_pqconn_object_t
*conn_obj
, long isolation
, zend_bool readonly
, zend_bool deferrable TSRMLS_DC
)
1441 STATUS rv
= FAILURE
;
1444 conn_obj
= zend_object_store_get_object(zconn TSRMLS_CC
);
1447 if (!conn_obj
->intern
) {
1448 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1450 smart_str cmd
= {0};
1451 const char *il
= isolation_level(&isolation
);
1453 smart_str_appends(&cmd
, "START TRANSACTION ISOLATION LEVEL ");
1454 smart_str_appends(&cmd
, il
);
1455 smart_str_appends(&cmd
, ", READ ");
1456 smart_str_appends(&cmd
, readonly
? "ONLY" : "WRITE");
1457 smart_str_appends(&cmd
, ",");
1458 smart_str_appends(&cmd
, deferrable
? "" : "NOT ");
1459 smart_str_appends(&cmd
, " DEFERRABLE");
1462 if (!PQsendQuery(conn_obj
->intern
->conn
, cmd
.c
)) {
1463 throw_exce(EX_IO TSRMLS_CC
, "Failed to start transaction (%s)", PHP_PQerrorMessage(conn_obj
->intern
->conn
));
1466 conn_obj
->intern
->poller
= PQconsumeInput
;
1467 php_pqconn_notify_listeners(conn_obj TSRMLS_CC
);
1470 smart_str_free(&cmd
);
1476 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_start_transaction
, 0, 0, 0)
1477 ZEND_ARG_INFO(0, isolation
)
1478 ZEND_ARG_INFO(0, readonly
)
1479 ZEND_ARG_INFO(0, deferrable
)
1480 ZEND_END_ARG_INFO();
1481 static PHP_METHOD(pqconn
, startTransaction
) {
1482 zend_error_handling zeh
;
1483 long isolation
= PHP_PQTXN_READ_COMMITTED
;
1484 zend_bool readonly
= 0, deferrable
= 0;
1487 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1488 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|lbb", &isolation
, &readonly
, &deferrable
);
1489 zend_restore_error_handling(&zeh TSRMLS_CC
);
1491 if (SUCCESS
== rv
) {
1492 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1494 rv
= php_pqconn_start_transaction(getThis(), obj
, isolation
, readonly
, deferrable TSRMLS_CC
);
1496 if (SUCCESS
== rv
) {
1497 php_pqtxn_t
*txn
= ecalloc(1, sizeof(*txn
));
1499 php_pq_object_addref(obj TSRMLS_CC
);
1502 txn
->isolation
= isolation
;
1503 txn
->readonly
= readonly
;
1504 txn
->deferrable
= deferrable
;
1506 return_value
->type
= IS_OBJECT
;
1507 return_value
->value
.obj
= php_pqtxn_create_object_ex(php_pqtxn_class_entry
, txn
, NULL TSRMLS_CC
);
1512 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_start_transaction_async
, 0, 0, 0)
1513 ZEND_ARG_INFO(0, isolation
)
1514 ZEND_ARG_INFO(0, readonly
)
1515 ZEND_ARG_INFO(0, deferrable
)
1516 ZEND_END_ARG_INFO();
1517 static PHP_METHOD(pqconn
, startTransactionAsync
) {
1518 zend_error_handling zeh
;
1519 long isolation
= PHP_PQTXN_READ_COMMITTED
;
1520 zend_bool readonly
= 0, deferrable
= 0;
1523 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1524 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|lbb", &isolation
, &readonly
, &deferrable
);
1525 zend_restore_error_handling(&zeh TSRMLS_CC
);
1526 if (SUCCESS
== rv
) {
1527 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1529 rv
= php_pqconn_start_transaction_async(getThis(), obj
, isolation
, readonly
, deferrable TSRMLS_CC
);
1531 if (SUCCESS
== rv
) {
1532 php_pqtxn_t
*txn
= ecalloc(1, sizeof(*txn
));
1534 php_pq_object_addref(obj TSRMLS_CC
);
1536 txn
->isolation
= isolation
;
1537 txn
->readonly
= readonly
;
1538 txn
->deferrable
= deferrable
;
1540 return_value
->type
= IS_OBJECT
;
1541 return_value
->value
.obj
= php_pqtxn_create_object_ex(php_pqtxn_class_entry
, txn
, NULL TSRMLS_CC
);
1546 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_trace
, 0, 0, 0)
1547 ZEND_ARG_INFO(0, stdio_stream
)
1548 ZEND_END_ARG_INFO();
1549 static PHP_METHOD(pqconn
, trace
) {
1550 zval
*zstream
= NULL
;
1552 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|r!", &zstream
)) {
1553 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1556 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1559 PQuntrace(obj
->intern
->conn
);
1563 php_stream
*stream
= NULL
;
1565 php_stream_from_zval(stream
, &zstream
);
1567 if (SUCCESS
!= php_stream_cast(stream
, PHP_STREAM_AS_STDIO
, (void *) &fp
, REPORT_ERRORS
)) {
1570 stream
->flags
|= PHP_STREAM_FLAG_NO_CLOSE
;
1571 PQtrace(obj
->intern
->conn
, fp
);
1579 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_on
, 0, 0, 2)
1580 ZEND_ARG_INFO(0, type
)
1581 ZEND_ARG_INFO(0, callable
)
1582 ZEND_END_ARG_INFO();
1583 static PHP_METHOD(pqconn
, on
) {
1584 zend_error_handling zeh
;
1587 php_pq_callback_t cb
= {{0}};
1590 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1591 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "sf", &type_str
, &type_len
, &cb
.fci
, &cb
.fcc
);
1592 zend_restore_error_handling(&zeh TSRMLS_CC
);
1594 if (SUCCESS
== rv
) {
1595 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1598 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1600 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1602 RETVAL_LONG(php_pqconn_add_eventhandler(obj
, type_str
, type_len
, &cb TSRMLS_CC
));
1607 static int apply_set_converter(void *p TSRMLS_DC
, int argc
, va_list argv
, zend_hash_key
*key
)
1609 zval
*tmp
, **zoid
= p
, **zcnv
= va_arg(argv
, zval
**);
1610 HashTable
*converters
= va_arg(argv
, HashTable
*);
1613 convert_to_long_ex(&tmp
);
1615 zend_hash_index_update(converters
, Z_LVAL_P(tmp
), zcnv
, sizeof(zval
*), NULL
);
1617 zval_ptr_dtor(&tmp
);
1620 return ZEND_HASH_APPLY_KEEP
;
1623 ZEND_BEGIN_ARG_INFO_EX(ai_pqconn_set_converter
, 0, 0, 1)
1624 ZEND_ARG_OBJ_INFO(0, converter
, pq
\\ConverterInterface
, 0)
1625 ZEND_END_ARG_INFO();
1626 static PHP_METHOD(pqconn
, setConverter
) {
1628 zend_error_handling zeh
;
1631 zend_replace_error_handling(EH_THROW
, exce(EX_INVALID_ARGUMENT
), &zeh TSRMLS_CC
);
1632 rv
= zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "O", &zcnv
, php_pqconv_class_entry
);
1633 zend_restore_error_handling(&zeh TSRMLS_CC
);
1635 if (SUCCESS
== rv
) {
1636 php_pqconn_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1639 throw_exce(EX_UNINITIALIZED TSRMLS_CC
, "pq\\Connection not initialized");
1641 zval
*tmp
, *zoids
= NULL
;
1643 zend_call_method_with_0_params(&zcnv
, NULL
, NULL
, "converttypes", &zoids
);
1645 convert_to_array_ex(&zoids
);
1646 zend_hash_apply_with_arguments(Z_ARRVAL_P(zoids
) TSRMLS_CC
, apply_set_converter
, 2, &zcnv
, &obj
->intern
->converters
);
1648 zval_ptr_dtor(&tmp
);
1650 zval_ptr_dtor(&zoids
);
1655 static zend_function_entry php_pqconn_methods
[] = {
1656 PHP_ME(pqconn
, __construct
, ai_pqconn_construct
, ZEND_ACC_PUBLIC
|ZEND_ACC_CTOR
)
1657 PHP_ME(pqconn
, reset
, ai_pqconn_reset
, ZEND_ACC_PUBLIC
)
1658 PHP_ME(pqconn
, resetAsync
, ai_pqconn_reset_async
, ZEND_ACC_PUBLIC
)
1659 PHP_ME(pqconn
, poll
, ai_pqconn_poll
, ZEND_ACC_PUBLIC
)
1660 PHP_ME(pqconn
, exec
, ai_pqconn_exec
, ZEND_ACC_PUBLIC
)
1661 PHP_ME(pqconn
, execAsync
, ai_pqconn_exec_async
, ZEND_ACC_PUBLIC
)
1662 PHP_ME(pqconn
, execParams
, ai_pqconn_exec_params
, ZEND_ACC_PUBLIC
)
1663 PHP_ME(pqconn
, execParamsAsync
, ai_pqconn_exec_params_async
, ZEND_ACC_PUBLIC
)
1664 PHP_ME(pqconn
, prepare
, ai_pqconn_prepare
, ZEND_ACC_PUBLIC
)
1665 PHP_ME(pqconn
, prepareAsync
, ai_pqconn_prepare_async
, ZEND_ACC_PUBLIC
)
1666 PHP_ME(pqconn
, declare
, ai_pqconn_declare
, ZEND_ACC_PUBLIC
)
1667 PHP_ME(pqconn
, declareAsync
, ai_pqconn_declare_async
, ZEND_ACC_PUBLIC
)
1668 PHP_ME(pqconn
, listen
, ai_pqconn_listen
, ZEND_ACC_PUBLIC
)
1669 PHP_ME(pqconn
, listenAsync
, ai_pqconn_listen_async
, ZEND_ACC_PUBLIC
)
1670 PHP_ME(pqconn
, notify
, ai_pqconn_notify
, ZEND_ACC_PUBLIC
)
1671 PHP_ME(pqconn
, notifyAsync
, ai_pqconn_notify_async
, ZEND_ACC_PUBLIC
)
1672 PHP_ME(pqconn
, getResult
, ai_pqconn_get_result
, ZEND_ACC_PUBLIC
)
1673 PHP_ME(pqconn
, quote
, ai_pqconn_quote
, ZEND_ACC_PUBLIC
)
1674 PHP_ME(pqconn
, quoteName
, ai_pqconn_quote_name
, ZEND_ACC_PUBLIC
)
1675 PHP_ME(pqconn
, escapeBytea
, ai_pqconn_escape_bytea
, ZEND_ACC_PUBLIC
)
1676 PHP_ME(pqconn
, unescapeBytea
, ai_pqconn_unescape_bytea
, ZEND_ACC_PUBLIC
)
1677 PHP_ME(pqconn
, startTransaction
, ai_pqconn_start_transaction
, ZEND_ACC_PUBLIC
)
1678 PHP_ME(pqconn
, startTransactionAsync
, ai_pqconn_start_transaction_async
, ZEND_ACC_PUBLIC
)
1679 PHP_ME(pqconn
, trace
, ai_pqconn_trace
, ZEND_ACC_PUBLIC
)
1680 PHP_ME(pqconn
, on
, ai_pqconn_on
, ZEND_ACC_PUBLIC
)
1681 PHP_ME(pqconn
, setConverter
, ai_pqconn_set_converter
, ZEND_ACC_PUBLIC
)
1685 PHP_MSHUTDOWN_FUNCTION(pqconn
)
1687 zend_hash_destroy(&php_pqconn_object_prophandlers
);
1691 PHP_MINIT_FUNCTION(pqconn
)
1693 zend_class_entry ce
= {0};
1694 php_pq_object_prophandler_t ph
= {0};
1696 INIT_NS_CLASS_ENTRY(ce
, "pq", "Connection", php_pqconn_methods
);
1697 php_pqconn_class_entry
= zend_register_internal_class_ex(&ce
, NULL
, NULL TSRMLS_CC
);
1698 php_pqconn_class_entry
->create_object
= php_pqconn_create_object
;
1700 memcpy(&php_pqconn_object_handlers
, zend_get_std_object_handlers(), sizeof(zend_object_handlers
));
1701 php_pqconn_object_handlers
.read_property
= php_pq_object_read_prop
;
1702 php_pqconn_object_handlers
.write_property
= php_pq_object_write_prop
;
1703 php_pqconn_object_handlers
.clone_obj
= NULL
;
1704 php_pqconn_object_handlers
.get_property_ptr_ptr
= NULL
;
1705 php_pqconn_object_handlers
.get_gc
= NULL
;
1706 php_pqconn_object_handlers
.get_properties
= php_pq_object_properties
;
1707 php_pqconn_object_handlers
.get_debug_info
= php_pq_object_debug_info
;
1709 zend_hash_init(&php_pqconn_object_prophandlers
, 14, NULL
, NULL
, 1);
1711 zend_declare_property_long(php_pqconn_class_entry
, ZEND_STRL("status"), CONNECTION_BAD
, ZEND_ACC_PUBLIC TSRMLS_CC
);
1712 ph
.read
= php_pqconn_object_read_status
;
1713 zend_hash_add(&php_pqconn_object_prophandlers
, "status", sizeof("status"), (void *) &ph
, sizeof(ph
), NULL
);
1715 zend_declare_property_long(php_pqconn_class_entry
, ZEND_STRL("transactionStatus"), PQTRANS_UNKNOWN
, ZEND_ACC_PUBLIC TSRMLS_CC
);
1716 ph
.read
= php_pqconn_object_read_transaction_status
;
1717 zend_hash_add(&php_pqconn_object_prophandlers
, "transactionStatus", sizeof("transactionStatus"), (void *) &ph
, sizeof(ph
), NULL
);
1719 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("socket"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1720 ph
.read
= NULL
; /* forward to std prophandler */
1721 zend_hash_add(&php_pqconn_object_prophandlers
, "socket", sizeof("socket"), (void *) &ph
, sizeof(ph
), NULL
);
1723 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("errorMessage"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1724 ph
.read
= php_pqconn_object_read_error_message
;
1725 zend_hash_add(&php_pqconn_object_prophandlers
, "errorMessage", sizeof("errorMessage"), (void *) &ph
, sizeof(ph
), NULL
);
1727 zend_declare_property_bool(php_pqconn_class_entry
, ZEND_STRL("busy"), 0, ZEND_ACC_PUBLIC TSRMLS_CC
);
1728 ph
.read
= php_pqconn_object_read_busy
;
1729 zend_hash_add(&php_pqconn_object_prophandlers
, "busy", sizeof("busy"), (void *) &ph
, sizeof(ph
), NULL
);
1731 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("encoding"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1732 ph
.read
= php_pqconn_object_read_encoding
;
1733 ph
.write
= php_pqconn_object_write_encoding
;
1734 zend_hash_add(&php_pqconn_object_prophandlers
, "encoding", sizeof("encoding"), (void *) &ph
, sizeof(ph
), NULL
);
1737 zend_declare_property_bool(php_pqconn_class_entry
, ZEND_STRL("unbuffered"), 0, ZEND_ACC_PUBLIC TSRMLS_CC
);
1738 ph
.read
= php_pqconn_object_read_unbuffered
;
1739 ph
.write
= php_pqconn_object_write_unbuffered
;
1740 zend_hash_add(&php_pqconn_object_prophandlers
, "unbuffered", sizeof("unbuffered"), (void *) &ph
, sizeof(ph
), NULL
);
1743 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("db"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1744 ph
.read
= php_pqconn_object_read_db
;
1745 zend_hash_add(&php_pqconn_object_prophandlers
, "db", sizeof("db"), (void *) &ph
, sizeof(ph
), NULL
);
1747 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("user"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1748 ph
.read
= php_pqconn_object_read_user
;
1749 zend_hash_add(&php_pqconn_object_prophandlers
, "user", sizeof("user"), (void *) &ph
, sizeof(ph
), NULL
);
1751 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("pass"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1752 ph
.read
= php_pqconn_object_read_pass
;
1753 zend_hash_add(&php_pqconn_object_prophandlers
, "pass", sizeof("pass"), (void *) &ph
, sizeof(ph
), NULL
);
1755 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("host"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1756 ph
.read
= php_pqconn_object_read_host
;
1757 zend_hash_add(&php_pqconn_object_prophandlers
, "host", sizeof("host"), (void *) &ph
, sizeof(ph
), NULL
);
1759 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("port"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1760 ph
.read
= php_pqconn_object_read_port
;
1761 zend_hash_add(&php_pqconn_object_prophandlers
, "port", sizeof("port"), (void *) &ph
, sizeof(ph
), NULL
);
1763 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("options"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1764 ph
.read
= php_pqconn_object_read_options
;
1765 zend_hash_add(&php_pqconn_object_prophandlers
, "options", sizeof("options"), (void *) &ph
, sizeof(ph
), NULL
);
1767 zend_declare_property_null(php_pqconn_class_entry
, ZEND_STRL("eventHandlers"), ZEND_ACC_PUBLIC TSRMLS_CC
);
1768 ph
.read
= php_pqconn_object_read_event_handlers
;
1769 zend_hash_add(&php_pqconn_object_prophandlers
, "eventHandlers", sizeof("eventHandlers"), (void *) &ph
, sizeof(ph
), NULL
);
1771 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("OK"), CONNECTION_OK TSRMLS_CC
);
1772 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("BAD"), CONNECTION_BAD TSRMLS_CC
);
1773 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("STARTED"), CONNECTION_STARTED TSRMLS_CC
);
1774 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("MADE"), CONNECTION_MADE TSRMLS_CC
);
1775 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("AWAITING_RESPONSE"), CONNECTION_AWAITING_RESPONSE TSRMLS_CC
);
1776 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("AUTH_OK"), CONNECTION_AUTH_OK TSRMLS_CC
);
1777 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("SSL_STARTUP"), CONNECTION_SSL_STARTUP TSRMLS_CC
);
1778 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("SETENV"), CONNECTION_SETENV TSRMLS_CC
);
1780 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("TRANS_IDLE"), PQTRANS_IDLE TSRMLS_CC
);
1781 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("TRANS_ACTIVE"), PQTRANS_ACTIVE TSRMLS_CC
);
1782 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("TRANS_INTRANS"), PQTRANS_INTRANS TSRMLS_CC
);
1783 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("TRANS_INERROR"), PQTRANS_INERROR TSRMLS_CC
);
1784 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("TRANS_UNKNOWN"), PQTRANS_UNKNOWN TSRMLS_CC
);
1786 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("POLLING_FAILED"), PGRES_POLLING_FAILED TSRMLS_CC
);
1787 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("POLLING_READING"), PGRES_POLLING_READING TSRMLS_CC
);
1788 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("POLLING_WRITING"), PGRES_POLLING_WRITING TSRMLS_CC
);
1789 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("POLLING_OK"), PGRES_POLLING_OK TSRMLS_CC
);
1791 zend_declare_class_constant_stringl(php_pqconn_class_entry
, ZEND_STRL("EVENT_NOTICE"), ZEND_STRL("notice") TSRMLS_CC
);
1792 zend_declare_class_constant_stringl(php_pqconn_class_entry
, ZEND_STRL("EVENT_RESULT"), ZEND_STRL("result") TSRMLS_CC
);
1793 zend_declare_class_constant_stringl(php_pqconn_class_entry
, ZEND_STRL("EVENT_RESET"), ZEND_STRL("reset") TSRMLS_CC
);
1795 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("ASYNC"), 0x1 TSRMLS_CC
);
1796 zend_declare_class_constant_long(php_pqconn_class_entry
, ZEND_STRL("PERSISTENT"), 0x2 TSRMLS_CC
);
1806 * vim600: noet sw=4 ts=4 fdm=marker
1807 * vim<600: noet sw=4 ts=4